diff --git a/Import/GacUI.cpp b/Import/GacUI.cpp index 17a38891..9ab76680 100644 --- a/Import/GacUI.cpp +++ b/Import/GacUI.cpp @@ -5488,7 +5488,7 @@ GuiControlHost GuiControl* GuiControlHost::GetTooltipOwner(Point location) { - GuiGraphicsComposition* composition=this->GetBoundsComposition()->FindComposition(location); + GuiGraphicsComposition* composition=this->GetBoundsComposition()->FindComposition(location, false); if(composition) { GuiControl* control=composition->GetRelatedControl(); @@ -7528,9 +7528,6 @@ GuiGraphicsComposition } GuiGraphicsComposition::GuiGraphicsComposition() - :visible(true) - ,minSizeLimitation(NoLimit) - ,associatedHitTestResult(INativeWindowListener::NoDecision) { sharedPtrDestructorProc = &GuiGraphicsComposition::SharedPtrDestructorProc; } @@ -7728,7 +7725,7 @@ GuiGraphicsComposition return eventReceiver; } - GuiGraphicsComposition* GuiGraphicsComposition::FindComposition(Point location) + GuiGraphicsComposition* GuiGraphicsComposition::FindComposition(Point location, bool forMouseEvent) { if (!visible) return 0; Rect bounds = GetBounds(); @@ -7743,18 +7740,29 @@ GuiGraphicsComposition vint offsetX = childBounds.x1 + (clientArea.x1 - bounds.x1); vint offsetY = childBounds.y1 + (clientArea.y1 - bounds.y1); Point newLocation = location - Size(offsetX, offsetY); - GuiGraphicsComposition* childResult = child->FindComposition(newLocation); + GuiGraphicsComposition* childResult = child->FindComposition(newLocation, forMouseEvent); if (childResult) { return childResult; } } - return this; - } - else - { - return 0; + + if (!forMouseEvent || !transparentToMouse) + { + return this; + } } + return nullptr; + } + + bool GuiGraphicsComposition::GetTransparentToMouse() + { + return transparentToMouse; + } + + void GuiGraphicsComposition::SetTransparentToMouse(bool value) + { + transparentToMouse = value; } Rect GuiGraphicsComposition::GetGlobalBounds() @@ -8501,6 +8509,2376 @@ GuiFlowItemComposition } } +/*********************************************************************** +.\CONTROLS\GUIAPPLICATION.CPP +***********************************************************************/ + +extern void GuiMain(); + +namespace vl +{ + namespace presentation + { + namespace controls + { + using namespace collections; + using namespace compositions; + using namespace theme; + using namespace description; + +/*********************************************************************** +GuiApplication +***********************************************************************/ + + void GuiApplication::InvokeClipboardNotify(compositions::GuiGraphicsComposition* composition, compositions::GuiEventArgs& arguments) + { + if(composition->HasEventReceiver()) + { + composition->GetEventReceiver()->clipboardNotify.Execute(arguments); + } + FOREACH(GuiGraphicsComposition*, subComposition, composition->Children()) + { + InvokeClipboardNotify(subComposition, arguments); + } + } + + void GuiApplication::LeftButtonDown(Point position) + { + OnMouseDown(position); + } + + void GuiApplication::LeftButtonUp(Point position) + { + } + + void GuiApplication::RightButtonDown(Point position) + { + OnMouseDown(position); + } + + void GuiApplication::RightButtonUp(Point position) + { + } + + void GuiApplication::ClipboardUpdated() + { + for(vint i=0;iGetNotifyEventArguments(); + windows[i]->ClipboardUpdated.Execute(arguments); + InvokeClipboardNotify(windows[i]->GetBoundsComposition(), arguments); + } + } + + GuiApplication::GuiApplication() + :mainWindow(0) + ,sharedTooltipOwnerWindow(0) + ,sharedTooltipOwner(0) + ,sharedTooltipControl(0) + ,sharedTooltipHovering(false) + ,sharedTooltipClosing(false) + { + GetCurrentController()->CallbackService()->InstallListener(this); + } + + GuiApplication::~GuiApplication() + { + if(sharedTooltipControl) + { + delete sharedTooltipControl; + sharedTooltipControl=0; + } + GetCurrentController()->CallbackService()->UninstallListener(this); + } + + void GuiApplication::RegisterWindow(GuiWindow* window) + { + windows.Add(window); + } + + void GuiApplication::UnregisterWindow(GuiWindow* window) + { + windows.Remove(window); + } + + void GuiApplication::RegisterPopupOpened(GuiPopup* popup) + { + vint index=openingPopups.IndexOf(popup); + if(index==-1) + { + openingPopups.Add(popup); + if(openingPopups.Count()==1) + { + GetCurrentController()->InputService()->StartHookMouse(); + } + } + } + + void GuiApplication::RegisterPopupClosed(GuiPopup* popup) + { + if(openingPopups.Remove(popup)) + { + if(openingPopups.Count()==0) + { + GetCurrentController()->InputService()->StopHookMouse(); + } + } + } + + void GuiApplication::OnMouseDown(Point location) + { + GuiWindow* window=GetWindow(location); + for(vint i=0;iMouseClickedOnOtherWindow(window); + } + } + } + + void GuiApplication::TooltipMouseEnter(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + sharedTooltipHovering=true; + } + + void GuiApplication::TooltipMouseLeave(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + sharedTooltipHovering=false; + if(sharedTooltipClosing) + { + CloseTooltip(); + } + } + + void GuiApplication::Run(GuiWindow* _mainWindow) + { + if(!mainWindow) + { + mainWindow=_mainWindow; + GetCurrentController()->WindowService()->Run(mainWindow->GetNativeWindow()); + mainWindow=0; + } + } + + GuiWindow* GuiApplication::GetMainWindow() + { + return mainWindow; + } + + const collections::List& GuiApplication::GetWindows() + { + return windows; + } + + GuiWindow* GuiApplication::GetWindow(Point location) + { + INativeWindow* nativeWindow=GetCurrentController()->WindowService()->GetWindow(location); + if(nativeWindow) + { + for(vint i=0;iGetNativeWindow()==nativeWindow) + { + return window; + } + } + } + return 0; + } + + void GuiApplication::ShowTooltip(GuiControl* owner, GuiControl* tooltip, vint preferredContentWidth, Point location) + { + GuiWindow* ownerWindow = dynamic_cast(owner->GetRelatedControlHost()); + if (sharedTooltipOwnerWindow != ownerWindow) + { + delete sharedTooltipControl; + sharedTooltipControl = 0; + } + + if(!sharedTooltipControl) + { + sharedTooltipControl = new GuiTooltip(theme::ThemeName::Tooltip); + if (ownerWindow) + { + if (auto tooltipStyle = ownerWindow->GetControlTemplateObject()->GetTooltipTemplate()) + { + sharedTooltipControl->SetControlTemplate(tooltipStyle); + } + } + sharedTooltipControl->GetBoundsComposition()->GetEventReceiver()->mouseEnter.AttachMethod(this, &GuiApplication::TooltipMouseEnter); + sharedTooltipControl->GetBoundsComposition()->GetEventReceiver()->mouseLeave.AttachMethod(this, &GuiApplication::TooltipMouseLeave); + } + + sharedTooltipHovering=false; + sharedTooltipClosing=false; + sharedTooltipOwnerWindow = ownerWindow; + sharedTooltipOwner=owner; + sharedTooltipControl->SetTemporaryContentControl(tooltip); + sharedTooltipControl->SetPreferredContentWidth(preferredContentWidth); + sharedTooltipControl->SetClientSize(Size(10, 10)); + sharedTooltipControl->ShowPopup(owner, location); + } + + void GuiApplication::CloseTooltip() + { + if(sharedTooltipControl) + { + if(sharedTooltipHovering) + { + sharedTooltipClosing=true; + } + else + { + sharedTooltipClosing=false; + sharedTooltipControl->Close(); + } + } + } + + GuiControl* GuiApplication::GetTooltipOwner() + { + if(!sharedTooltipControl) return 0; + if(!sharedTooltipControl->GetTemporaryContentControl()) return 0; + return sharedTooltipOwner; + } + + WString GuiApplication::GetExecutablePath() + { + return GetCurrentController()->GetExecutablePath(); + } + + WString GuiApplication::GetExecutableFolder() + { + WString path=GetExecutablePath(); + for(vint i=path.Length()-1;i>=0;i--) + { + if(path[i]==L'\\' || path[i]==L'/') + { + return path.Sub(0, i+1); + } + } + return L""; + } + + bool GuiApplication::IsInMainThread() + { + return GetCurrentController()->AsyncService()->IsInMainThread(); + } + + void GuiApplication::InvokeAsync(const Func& proc) + { + GetCurrentController()->AsyncService()->InvokeAsync(proc); + } + + void GuiApplication::InvokeInMainThread(const Func& proc) + { + GetCurrentController()->AsyncService()->InvokeInMainThread(proc); + } + + bool GuiApplication::InvokeInMainThreadAndWait(const Func& proc, vint milliseconds) + { + return GetCurrentController()->AsyncService()->InvokeInMainThreadAndWait(proc, milliseconds); + } + + Ptr GuiApplication::DelayExecute(const Func& proc, vint milliseconds) + { + return GetCurrentController()->AsyncService()->DelayExecute(proc, milliseconds); + } + + Ptr GuiApplication::DelayExecuteInMainThread(const Func& proc, vint milliseconds) + { + return GetCurrentController()->AsyncService()->DelayExecuteInMainThread(proc, milliseconds); + } + + void GuiApplication::RunGuiTask(const Func& proc) + { + if(IsInMainThread()) + { + return proc(); + } + else + { + InvokeInMainThreadAndWait([&proc]() + { + proc(); + }); + } + } + +/*********************************************************************** +GuiPluginManager +***********************************************************************/ + + class GuiPluginManager : public Object, public IGuiPluginManager + { + protected: + List> plugins; + bool loaded; + public: + GuiPluginManager() + :loaded(false) + { + } + + ~GuiPluginManager() + { + Unload(); + } + + void AddPlugin(Ptr plugin)override + { + CHECK_ERROR(!loaded, L"GuiPluginManager::AddPlugin(Ptr)#Load function has already been executed."); + auto name = plugin->GetName(); + if (name != L"") + { + FOREACH(Ptr, plugin, plugins) + { + CHECK_ERROR(plugin->GetName() != name, L"GuiPluginManager::AddPlugin(Ptr)#Duplicated plugin name."); + } + } + plugins.Add(plugin); + } + + void Load()override + { + CHECK_ERROR(!loaded, L"GuiPluginManager::AddPlugin(Ptr)#Load function has already been executed."); + loaded=true; + + SortedList loaded; + Group loading; + Dictionary> pluginsToLoad; + FOREACH(Ptr, plugin, plugins) + { + auto name = plugin->GetName(); + pluginsToLoad.Add(name, plugin); + List dependencies; + plugin->GetDependencies(dependencies); + FOREACH(WString, dependency, dependencies) + { + loading.Add(name, dependency); + } + } + + while (pluginsToLoad.Count() > 0) + { + vint count = pluginsToLoad.Count(); + { + FOREACH_INDEXER(WString, name, index, pluginsToLoad.Keys()) + { + if (!loading.Keys().Contains(name)) + { + for (vint i = loading.Count() - 1; i >= 0; i--) + { + loading.Remove(loading.Keys()[i], name); + } + loaded.Add(name); + + auto plugin = pluginsToLoad.Values()[index]; + pluginsToLoad.Remove(name); + plugin->Load(); + break; + } + } + } + if (count == pluginsToLoad.Count()) + { + WString message; + FOREACH(Ptr, plugin, pluginsToLoad.Values()) + { + message += L"Cannot load plugin \"" + plugin->GetName() + L"\" because part of its dependencies are not ready:"; + List dependencies; + plugin->GetDependencies(dependencies); + bool first = true; + FOREACH(WString, dependency, dependencies) + { + if (!loaded.Contains(dependency)) + { + message += L" \"" + dependency + L"\";"; + } + } + message += L"\r\n"; + } + throw Exception(message); + } + } + } + + void Unload()override + { + CHECK_ERROR(loaded, L"GuiPluginManager::AddPlugin(Ptr)#Load function has not been executed."); + loaded=false; + FOREACH(Ptr, plugin, plugins) + { + plugin->Unload(); + } + } + + bool IsLoaded()override + { + return loaded; + } + }; + +/*********************************************************************** +Helpers +***********************************************************************/ + + GuiApplication* application=0; + IGuiPluginManager* pluginManager=0; + + GuiApplication* GetApplication() + { + return application; + } + + IGuiPluginManager* GetPluginManager() + { + if(!pluginManager) + { + pluginManager=new GuiPluginManager; + } + return pluginManager; + } + + void DestroyPluginManager() + { + if(pluginManager) + { + delete pluginManager; + pluginManager=0; + } + } + +/*********************************************************************** +GuiApplicationMain +***********************************************************************/ + + class UIThreadAsyncScheduler :public Object, public IAsyncScheduler, public Description + { + public: + void Execute(const Func& callback)override + { + GetApplication()->InvokeInMainThread(callback); + } + + void ExecuteInBackground(const Func& callback)override + { + GetApplication()->InvokeAsync(callback); + } + + void DelayExecute(const Func& callback, vint milliseconds)override + { + GetApplication()->DelayExecuteInMainThread(callback, milliseconds); + } + }; + + class OtherThreadAsyncScheduler :public Object, public IAsyncScheduler, public Description + { + public: + void Execute(const Func& callback)override + { + GetApplication()->InvokeAsync(callback); + } + + void ExecuteInBackground(const Func& callback)override + { + GetApplication()->InvokeAsync(callback); + } + + void DelayExecute(const Func& callback, vint milliseconds)override + { + GetApplication()->DelayExecute(callback, milliseconds); + } + }; + + void GuiApplicationInitialize() + { + GetCurrentController()->InputService()->StartTimer(); + theme::InitializeTheme(); + +#ifndef VCZH_DEBUG_NO_REFLECTION + GetGlobalTypeManager()->Load(); +#endif + GetPluginManager()->Load(); + + { + GuiApplication app; + application = &app; + IAsyncScheduler::RegisterSchedulerForCurrentThread(new UIThreadAsyncScheduler); + IAsyncScheduler::RegisterDefaultScheduler(new OtherThreadAsyncScheduler); + GuiMain(); + IAsyncScheduler::UnregisterDefaultScheduler(); + IAsyncScheduler::UnregisterSchedulerForCurrentThread(); + application = nullptr; + } + + DestroyPluginManager(); + theme::FinalizeTheme(); + ThreadLocalStorage::DisposeStorages(); + FinalizeGlobalStorage(); +#ifndef VCZH_DEBUG_NO_REFLECTION + DestroyGlobalTypeManager(); +#endif + } + } + } +} + +void GuiApplicationMain() +{ + vl::presentation::controls::GuiApplicationInitialize(); +} + +/*********************************************************************** +.\CONTROLS\GUIBASICCONTROLS.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace controls + { + using namespace elements; + using namespace compositions; + using namespace collections; + using namespace reflection::description; + +/*********************************************************************** +GuiControl +***********************************************************************/ + + void GuiControl::BeforeControlTemplateUninstalled() + { + } + + void GuiControl::AfterControlTemplateInstalled(bool initialize) + { + controlTemplateObject->SetText(text); + controlTemplateObject->SetFont(font); + controlTemplateObject->SetVisuallyEnabled(isVisuallyEnabled); + controlTemplateObject->SetFocusableComposition(focusableComposition); + } + + void GuiControl::CheckAndStoreControlTemplate(templates::GuiControlTemplate* value) + { + controlTemplateObject = value; + } + + void GuiControl::EnsureControlTemplateExists() + { + if (!controlTemplateObject) + { + RebuildControlTemplate(); + } + } + + void GuiControl::RebuildControlTemplate() + { + bool initialize = controlTemplateObject == nullptr; + if (controlTemplateObject) + { + BeforeControlTemplateUninstalled(); + containerComposition->GetParent()->RemoveChild(containerComposition); + boundsComposition->AddChild(containerComposition); + SafeDeleteComposition(controlTemplateObject); + controlTemplateObject = nullptr; + } + + if (controlTemplate) + { + CheckAndStoreControlTemplate(controlTemplate({})); + } + else + { + CheckAndStoreControlTemplate(theme::GetCurrentTheme()->CreateStyle(controlThemeName)({})); + } + + if (controlTemplateObject) + { + controlTemplateObject->SetAlignmentToParent(Margin(0, 0, 0, 0)); + + containerComposition->GetParent()->RemoveChild(containerComposition); + boundsComposition->AddChild(controlTemplateObject); + controlTemplateObject->GetContainerComposition()->AddChild(containerComposition); + AfterControlTemplateInstalled(initialize); + } + } + + void GuiControl::OnChildInserted(GuiControl* control) + { + GuiControl* oldParent=control->parent; + children.Add(control); + control->parent=this; + control->OnParentChanged(oldParent, control->parent); + control->UpdateVisuallyEnabled(); + } + + void GuiControl::OnChildRemoved(GuiControl* control) + { + GuiControl* oldParent=control->parent; + control->parent=0; + children.Remove(control); + control->OnParentChanged(oldParent, control->parent); + } + + void GuiControl::OnParentChanged(GuiControl* oldParent, GuiControl* newParent) + { + OnParentLineChanged(); + } + + void GuiControl::OnParentLineChanged() + { + for(vint i=0;iOnParentLineChanged(); + } + } + + void GuiControl::OnRenderTargetChanged(elements::IGuiGraphicsRenderTarget* renderTarget) + { + RenderTargetChanged.Execute(GetNotifyEventArguments()); + } + + void GuiControl::OnBeforeReleaseGraphicsHost() + { + for(vint i=0;iOnBeforeReleaseGraphicsHost(); + } + } + + void GuiControl::UpdateVisuallyEnabled() + { + bool newValue = isEnabled && (parent == 0 ? true : parent->GetVisuallyEnabled()); + if (isVisuallyEnabled != newValue) + { + isVisuallyEnabled = newValue; + if (controlTemplateObject) + { + controlTemplateObject->SetVisuallyEnabled(isVisuallyEnabled); + } + VisuallyEnabledChanged.Execute(GetNotifyEventArguments()); + + for (vint i = 0; i < children.Count(); i++) + { + children[i]->UpdateVisuallyEnabled(); + } + } + } + + void GuiControl::SetFocusableComposition(compositions::GuiGraphicsComposition* value) + { + if (focusableComposition != value) + { + focusableComposition = value; + if (controlTemplateObject) + { + controlTemplateObject->SetFocusableComposition(focusableComposition); + } + } + } + + bool GuiControl::IsAltEnabled() + { + GuiControl* control = this; + while (control) + { + if (!control->GetVisible() || !control->GetEnabled()) + { + return false; + } + control = control->GetParent(); + } + + return true; + } + + bool GuiControl::IsAltAvailable() + { + return focusableComposition != 0 && alt != L""; + } + + compositions::GuiGraphicsComposition* GuiControl::GetAltComposition() + { + return boundsComposition; + } + + compositions::IGuiAltActionHost* GuiControl::GetActivatingAltHost() + { + return activatingAltHost; + } + + void GuiControl::OnActiveAlt() + { + SetFocus(); + } + + bool GuiControl::SharedPtrDestructorProc(DescriptableObject* obj, bool forceDisposing) + { + GuiControl* value=dynamic_cast(obj); + if(value->GetBoundsComposition()->GetParent()) + { + if (!forceDisposing) return false; + } + SafeDeleteControl(value); + return true; + } + + GuiControl::GuiControl(theme::ThemeName themeName) + :controlThemeName(themeName) + { + { + boundsComposition = new GuiBoundsComposition; + boundsComposition->SetAssociatedControl(this); + boundsComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + + containerComposition = new GuiBoundsComposition; + containerComposition->SetTransparentToMouse(true); + containerComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + containerComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + + boundsComposition->AddChild(containerComposition); + } + { + ControlTemplateChanged.SetAssociatedComposition(boundsComposition); + RenderTargetChanged.SetAssociatedComposition(boundsComposition); + VisibleChanged.SetAssociatedComposition(boundsComposition); + EnabledChanged.SetAssociatedComposition(boundsComposition); + VisuallyEnabledChanged.SetAssociatedComposition(boundsComposition); + AltChanged.SetAssociatedComposition(boundsComposition); + TextChanged.SetAssociatedComposition(boundsComposition); + FontChanged.SetAssociatedComposition(boundsComposition); + } + font = GetCurrentController()->ResourceService()->GetDefaultFont(); + sharedPtrDestructorProc = &GuiControl::SharedPtrDestructorProc; + } + + GuiControl::~GuiControl() + { + // prevent a root bounds composition from notifying its dead controls + if (!parent) + { + NotifyFinalizeInstance(boundsComposition); + } + + if (tooltipControl) + { + // the only legal parent is the GuiApplication::sharedTooltipWindow + if (tooltipControl->GetBoundsComposition()->GetParent()) + { + tooltipControl->GetBoundsComposition()->GetParent()->RemoveChild(tooltipControl->GetBoundsComposition()); + } + delete tooltipControl; + } + + for (vint i = 0; i < children.Count(); i++) + { + delete children[i]; + } + children.Clear(); + + // let the root control of a control tree delete the whole composition tree + if (!parent) + { + delete boundsComposition; + } + } + + compositions::GuiEventArgs GuiControl::GetNotifyEventArguments() + { + return GuiEventArgs(boundsComposition); + } + + GuiControl::ControlTemplatePropertyType GuiControl::GetControlTemplate() + { + return controlTemplate; + } + + void GuiControl::SetControlTemplate(const ControlTemplatePropertyType& value) + { + controlTemplate = value; + RebuildControlTemplate(); + ControlTemplateChanged.Execute(GetNotifyEventArguments()); + } + + templates::GuiControlTemplate* GuiControl::GetControlTemplateObject() + { + EnsureControlTemplateExists(); + return controlTemplateObject; + } + + compositions::GuiBoundsComposition* GuiControl::GetBoundsComposition() + { + EnsureControlTemplateExists(); + return boundsComposition; + } + + compositions::GuiGraphicsComposition* GuiControl::GetContainerComposition() + { + EnsureControlTemplateExists(); + return containerComposition; + } + + compositions::GuiGraphicsComposition* GuiControl::GetFocusableComposition() + { + EnsureControlTemplateExists(); + return focusableComposition; + } + + GuiControl* GuiControl::GetParent() + { + return parent; + } + + vint GuiControl::GetChildrenCount() + { + return children.Count(); + } + + GuiControl* GuiControl::GetChild(vint index) + { + return children[index]; + } + + bool GuiControl::AddChild(GuiControl* control) + { + return GetContainerComposition()->AddChild(control->GetBoundsComposition()); + } + + bool GuiControl::HasChild(GuiControl* control) + { + return children.Contains(control); + } + + GuiControlHost* GuiControl::GetRelatedControlHost() + { + return parent?parent->GetRelatedControlHost():0; + } + + bool GuiControl::GetVisuallyEnabled() + { + return isVisuallyEnabled; + } + + bool GuiControl::GetEnabled() + { + return isEnabled; + } + + void GuiControl::SetEnabled(bool value) + { + if(isEnabled!=value) + { + isEnabled=value; + EnabledChanged.Execute(GetNotifyEventArguments()); + UpdateVisuallyEnabled(); + } + } + + bool GuiControl::GetVisible() + { + return isVisible; + } + + void GuiControl::SetVisible(bool value) + { + boundsComposition->SetVisible(value); + if(isVisible!=value) + { + isVisible=value; + VisibleChanged.Execute(GetNotifyEventArguments()); + } + } + + const WString& GuiControl::GetAlt() + { + return alt; + } + + bool GuiControl::SetAlt(const WString& value) + { + if (!IGuiAltAction::IsLegalAlt(value)) return false; + if (alt != value) + { + alt = value; + AltChanged.Execute(GetNotifyEventArguments()); + } + return true; + } + + void GuiControl::SetActivatingAltHost(compositions::IGuiAltActionHost* host) + { + activatingAltHost = host; + } + + const WString& GuiControl::GetText() + { + return text; + } + + void GuiControl::SetText(const WString& value) + { + if (text != value) + { + text = value; + if (controlTemplateObject) + { + controlTemplateObject->SetText(text); + } + TextChanged.Execute(GetNotifyEventArguments()); + } + } + + const FontProperties& GuiControl::GetFont() + { + return font; + } + + void GuiControl::SetFont(const FontProperties& value) + { + if (font != value) + { + font = value; + if (controlTemplateObject) + { + controlTemplateObject->SetFont(font); + } + FontChanged.Execute(GetNotifyEventArguments()); + } + } + + void GuiControl::SetFocus() + { + if(focusableComposition) + { + GuiGraphicsHost* host=focusableComposition->GetRelatedGraphicsHost(); + if(host) + { + host->SetFocus(focusableComposition); + } + } + } + + description::Value GuiControl::GetTag() + { + return tag; + } + + void GuiControl::SetTag(const description::Value& value) + { + tag=value; + } + + GuiControl* GuiControl::GetTooltipControl() + { + return tooltipControl; + } + + GuiControl* GuiControl::SetTooltipControl(GuiControl* value) + { + GuiControl* oldTooltipControl=tooltipControl; + tooltipControl=value; + return oldTooltipControl; + } + + vint GuiControl::GetTooltipWidth() + { + return tooltipWidth; + } + + void GuiControl::SetTooltipWidth(vint value) + { + tooltipWidth=value; + } + + bool GuiControl::DisplayTooltip(Point location) + { + if(!tooltipControl) return false; + GetApplication()->ShowTooltip(this, tooltipControl, tooltipWidth, location); + return true; + } + + void GuiControl::CloseTooltip() + { + if(GetApplication()->GetTooltipOwner()==this) + { + GetApplication()->CloseTooltip(); + } + } + + IDescriptable* GuiControl::QueryService(const WString& identifier) + { + if (identifier == IGuiAltAction::Identifier) + { + return (IGuiAltAction*)this; + } + else if (identifier == IGuiAltActionContainer::Identifier) + { + return 0; + } + else if(parent) + { + return parent->QueryService(identifier); + } + else + { + return 0; + } + } + +/*********************************************************************** +GuiCustomControl +***********************************************************************/ + + GuiCustomControl::GuiCustomControl(theme::ThemeName themeName) + :GuiControl(themeName) + { + } + + GuiCustomControl::~GuiCustomControl() + { + FinalizeAggregation(); + FinalizeInstanceRecursively(this); + } + } + } +} + +/*********************************************************************** +.\CONTROLS\TEMPLATES\GUITHEMESTYLEFACTORY.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace theme + { + using namespace collections; + using namespace controls; + using namespace templates; + + class Theme : public Object, public virtual theme::ITheme + { + public: + Dictionary> templates; + ThemeTemplates* first = nullptr; + ThemeTemplates* last = nullptr; + + bool RegisterTheme(const WString& name, Ptr theme) + { + CHECK_ERROR(theme->previous == nullptr, L"vl::presentation::theme::RegisterTheme(const WString&, Ptr)#Theme object has been registered"); + CHECK_ERROR(theme->next == nullptr, L"vl::presentation::theme::RegisterTheme(const WString&, Ptr)#Theme object has been registered"); + + if (templates.Keys().Contains(name)) + { + return false; + } + templates.Add(name, theme); + + if (last) + { + last->next = theme.Obj(); + } + theme->previous = last; + last = theme.Obj(); + + return true; + } + + Ptr UnregisterTheme(const WString& name) + { + vint index = templates.Keys().IndexOf(name); + if (index == -1) + { + return nullptr; + } + + auto themeTemplates = templates.Values().Get(index); + + if (themeTemplates->previous) + { + themeTemplates->previous->next = themeTemplates->next; + } + else + { + first = themeTemplates->next; + } + + if (themeTemplates->next) + { + themeTemplates->next->previous = themeTemplates->previous; + + } + else + { + last = themeTemplates->previous; + } + + templates.Remove(name); + return themeTemplates; + } + + TemplateProperty CreateStyle(ThemeName themeName)override + { + switch (themeName) + { +#define GUI_DEFINE_ITEM_PROPERTY(TEMPLATE, CONTROL) \ + case ThemeName::CONTROL:\ + {\ + auto current = last;\ + while (current) \ + {\ + if (current->CONTROL)\ + {\ + return current->CONTROL; \ + }\ + current = current->previous;\ + }\ + throw Exception(L"Control template for \"" L ## #CONTROL L"\" is not defined.");\ + }\ + + GUI_CONTROL_TEMPLATE_TYPES(GUI_DEFINE_ITEM_PROPERTY) +#undef GUI_DEFINE_ITEM_PROPERTY + default: + CHECK_FAIL(L"vl::presentation::theme::ITheme::CreateStyle(ThemeName)#Unknown theme name."); + } + } + }; + + ThemeTemplates::~ThemeTemplates() + { + FinalizeAggregation(); + } + + Theme* currentTheme = nullptr; + + ITheme* GetCurrentTheme() + { + return currentTheme; + } + + void InitializeTheme() + { + CHECK_ERROR(currentTheme == nullptr, L"vl::presentation::theme::InitializeTheme()#Theme has already been initialized"); + currentTheme = new Theme; + } + + void FinalizeTheme() + { + CHECK_ERROR(currentTheme != nullptr, L"vl::presentation::theme::FinalizeTheme()#Theme has not been initialized"); + delete currentTheme; + currentTheme = nullptr; + } + + bool RegisterTheme(const WString& name, Ptr theme) + { + CHECK_ERROR(currentTheme != nullptr, L"vl::presentation::theme::RegisterTheme(const WString&, Ptr)#Theme has already been initialized"); + return currentTheme->RegisterTheme(name, theme); + } + + Ptr UnregisterTheme(const WString& name) + { + CHECK_ERROR(currentTheme != nullptr, L"vl::presentation::theme::UnregisterTheme(const WString&)#Theme has already been initialized"); + return currentTheme->UnregisterTheme(name); + } + } + } +} + +/*********************************************************************** +.\GRAPHICSELEMENT\GUIGRAPHICSHOST.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace compositions + { + using namespace collections; + using namespace controls; + using namespace elements; + using namespace theme; + +/*********************************************************************** +GuiGraphicsAnimationManager +***********************************************************************/ + + GuiGraphicsAnimationManager::GuiGraphicsAnimationManager() + { + } + + GuiGraphicsAnimationManager::~GuiGraphicsAnimationManager() + { + } + + void GuiGraphicsAnimationManager::AddAnimation(Ptr animation) + { + playingAnimations.Add(animation); + } + + bool GuiGraphicsAnimationManager::HasAnimation() + { + return playingAnimations.Count()>0; + } + + void GuiGraphicsAnimationManager::Play() + { + for(vint i=playingAnimations.Count()-1;i>=0;i--) + { + Ptr animation=playingAnimations[i]; + vint totalLength=animation->GetTotalLength(); + vint currentPosition=animation->GetCurrentPosition(); + animation->Play(currentPosition, totalLength); + if(currentPosition>=totalLength) + { + playingAnimations.RemoveAt(i); + animation->Stop(); + } + } + } + +/*********************************************************************** +IGuiAltAction +***********************************************************************/ + + const wchar_t* const IGuiAltAction::Identifier = L"vl::presentation::compositions::IGuiAltAction"; + const wchar_t* const IGuiAltActionContainer::Identifier = L"vl::presentation::compositions::IGuiAltAction"; + const wchar_t* const IGuiAltActionHost::Identifier = L"vl::presentation::compositions::IGuiAltAction"; + + bool IGuiAltAction::IsLegalAlt(const WString& alt) + { + for (vint i = 0; i < alt.Length(); i++) + { + if (alt[i] < L'A' || L'Z' < alt[i]) + { + return false; + } + } + return true; + } + + void IGuiAltActionHost::CollectAltActionsFromControl(controls::GuiControl* control, collections::Group& actions) + { + List controls; + controls.Add(control); + vint current = 0; + + while (current < controls.Count()) + { + GuiControl* control = controls[current++]; + + if (auto container = control->QueryTypedService()) + { + vint count = container->GetAltActionCount(); + for (vint i = 0; i < count; i++) + { + auto action = container->GetAltAction(i); + actions.Add(action->GetAlt(), action); + } + continue; + } + else if (auto action = control->QueryTypedService()) + { + if (action->IsAltAvailable()) + { + if (action->IsAltEnabled()) + { + actions.Add(action->GetAlt(), action); + continue; + } + } + } + + vint count = control->GetChildrenCount(); + for (vint i = 0; i < count; i++) + { + controls.Add(control->GetChild(i)); + } + } + } + +/*********************************************************************** +GuiGraphicsHost +***********************************************************************/ + + void GuiGraphicsHost::EnterAltHost(IGuiAltActionHost* host) + { + ClearAltHost(); + + Group actions; + host->CollectAltActions(actions); + if (actions.Count() == 0) + { + CloseAltHost(); + return; + } + + host->OnActivatedAltHost(currentAltHost); + currentAltHost = host; + CreateAltTitles(actions); + } + + void GuiGraphicsHost::LeaveAltHost() + { + if (currentAltHost) + { + ClearAltHost(); + auto previousHost = currentAltHost->GetPreviousAltHost(); + currentAltHost->OnDeactivatedAltHost(); + currentAltHost = previousHost; + + if (currentAltHost) + { + Group actions; + currentAltHost->CollectAltActions(actions); + CreateAltTitles(actions); + } + } + } + + bool GuiGraphicsHost::EnterAltKey(wchar_t key) + { + currentAltPrefix += key; + vint index = currentActiveAltActions.Keys().IndexOf(currentAltPrefix); + if (index == -1) + { + if (FilterTitles() == 0) + { + currentAltPrefix = currentAltPrefix.Left(currentAltPrefix.Length() - 1); + FilterTitles(); + } + } + else + { + auto action = currentActiveAltActions.Values()[index]; + if (action->GetActivatingAltHost()) + { + EnterAltHost(action->GetActivatingAltHost()); + } + else + { + CloseAltHost(); + } + action->OnActiveAlt(); + return true; + } + return false; + } + + void GuiGraphicsHost::LeaveAltKey() + { + if (currentAltPrefix.Length() >= 1) + { + currentAltPrefix = currentAltPrefix.Left(currentAltPrefix.Length() - 1); + } + FilterTitles(); + } + + void GuiGraphicsHost::CreateAltTitles(const collections::Group& actions) + { + if (currentAltHost) + { + vint count = actions.Count(); + for (vint i = 0; i < count; i++) + { + WString key = actions.Keys()[i]; + const auto& values = actions.GetByIndex(i); + vint numberLength = 0; + if (values.Count() == 1 && key.Length() > 0) + { + numberLength = 0; + } + else if (values.Count() <= 10) + { + numberLength = 1; + } + else if (values.Count() <= 100) + { + numberLength = 2; + } + else if (values.Count() <= 1000) + { + numberLength = 3; + } + else + { + continue; + } + + FOREACH_INDEXER(IGuiAltAction*, action, index, values) + { + WString key = actions.Keys()[i]; + if (numberLength > 0) + { + WString number = itow(index); + while (number.Length() < numberLength) + { + number = L"0" + number; + } + key += number; + } + currentActiveAltActions.Add(key, action); + } + } + + count = currentActiveAltActions.Count(); + auto window = dynamic_cast(currentAltHost->GetAltComposition()->GetRelatedControlHost()); + for (vint i = 0; i < count; i++) + { + auto key = currentActiveAltActions.Keys()[i]; + auto composition = currentActiveAltActions.Values()[i]->GetAltComposition(); + + auto label = new GuiLabel(theme::ThemeName::ShortcutKey); + if (auto labelStyle = window->GetControlTemplateObject()->GetShortcutKeyTemplate()) + { + label->SetControlTemplate(labelStyle); + } + label->SetText(key); + composition->AddChild(label->GetBoundsComposition()); + currentActiveAltTitles.Add(key, label); + } + + FilterTitles(); + } + } + + vint GuiGraphicsHost::FilterTitles() + { + vint count = currentActiveAltTitles.Count(); + vint visibles = 0; + for (vint i = 0; i < count; i++) + { + auto key = currentActiveAltTitles.Keys()[i]; + auto value = currentActiveAltTitles.Values()[i]; + if (key.Length() >= currentAltPrefix.Length() && key.Left(currentAltPrefix.Length()) == currentAltPrefix) + { + value->SetVisible(true); + if (currentAltPrefix.Length() <= key.Length()) + { + value->SetText( + key + .Insert(currentAltPrefix.Length(), L"[") + .Insert(currentAltPrefix.Length() + 2, L"]") + ); + } + else + { + value->SetText(key); + } + visibles++; + } + else + { + value->SetVisible(false); + } + } + return visibles; + } + + void GuiGraphicsHost::ClearAltHost() + { + FOREACH(GuiControl*, title, currentActiveAltTitles.Values()) + { + SafeDeleteControl(title); + } + currentActiveAltActions.Clear(); + currentActiveAltTitles.Clear(); + currentAltPrefix = L""; + } + + void GuiGraphicsHost::CloseAltHost() + { + ClearAltHost(); + while (currentAltHost) + { + currentAltHost->OnDeactivatedAltHost(); + currentAltHost = currentAltHost->GetPreviousAltHost(); + } + } + + void GuiGraphicsHost::RefreshRelatedHostRecord(INativeWindow* nativeWindow) + { + hostRecord.nativeWindow = nativeWindow; + hostRecord.renderTarget = nativeWindow ? GetGuiGraphicsResourceManager()->GetRenderTarget(nativeWindow) : nullptr; + windowComposition->UpdateRelatedHostRecord(&hostRecord); + } + + void GuiGraphicsHost::DisconnectCompositionInternal(GuiGraphicsComposition* composition) + { + for(vint i=0;iChildren().Count();i++) + { + DisconnectCompositionInternal(composition->Children().Get(i)); + } + if(mouseCaptureComposition==composition) + { + if(hostRecord.nativeWindow) + { + hostRecord.nativeWindow->ReleaseCapture(); + } + mouseCaptureComposition=0; + } + if(focusedComposition==composition) + { + focusedComposition=0; + } + mouseEnterCompositions.Remove(composition); + } + + void GuiGraphicsHost::MouseCapture(const NativeWindowMouseInfo& info) + { + if(hostRecord.nativeWindow && (info.left || info.middle || info.right)) + { + if(!hostRecord.nativeWindow->IsCapturing() && !info.nonClient) + { + hostRecord.nativeWindow->RequireCapture(); + mouseCaptureComposition=windowComposition->FindComposition(Point(info.x, info.y), true); + } + } + } + + void GuiGraphicsHost::MouseUncapture(const NativeWindowMouseInfo& info) + { + if(hostRecord.nativeWindow && !(info.left || info.middle || info.right)) + { + hostRecord.nativeWindow->ReleaseCapture(); + mouseCaptureComposition=0; + } + } + + void GuiGraphicsHost::OnCharInput(const NativeWindowCharInfo& info, GuiGraphicsComposition* composition, GuiCharEvent GuiGraphicsEventReceiver::* eventReceiverEvent) + { + List compositions; + while(composition) + { + if(composition->HasEventReceiver()) + { + compositions.Add(composition); + } + composition=composition->GetParent(); + } + + GuiCharEventArgs arguments(composition); + (NativeWindowCharInfo&)arguments=info; + + for(vint i=compositions.Count()-1;i>=0;i--) + { + compositions[i]->GetEventReceiver()->previewCharInput.Execute(arguments); + if(arguments.handled) + { + return; + } + } + + for(vint i=0;iGetEventReceiver()->*eventReceiverEvent).Execute(arguments); + if(arguments.handled) + { + return; + } + } + } + + void GuiGraphicsHost::OnKeyInput(const NativeWindowKeyInfo& info, GuiGraphicsComposition* composition, GuiKeyEvent GuiGraphicsEventReceiver::* eventReceiverEvent) + { + List compositions; + while(composition) + { + if(composition->HasEventReceiver()) + { + compositions.Add(composition); + } + composition=composition->GetParent(); + } + + GuiKeyEventArgs arguments(composition); + (NativeWindowKeyInfo&)arguments=info; + + for(vint i=compositions.Count()-1;i>=0;i--) + { + compositions[i]->GetEventReceiver()->previewKey.Execute(arguments); + if(arguments.handled) + { + return; + } + } + + for(vint i=0;iGetEventReceiver()->*eventReceiverEvent).Execute(arguments); + if(arguments.handled) + { + return; + } + } + } + + void GuiGraphicsHost::RaiseMouseEvent(GuiMouseEventArgs& arguments, GuiGraphicsComposition* composition, GuiMouseEvent GuiGraphicsEventReceiver::* eventReceiverEvent) + { + arguments.compositionSource=composition; + arguments.eventSource=0; + vint x=arguments.x; + vint y=arguments.y; + + while(composition) + { + if(composition->HasEventReceiver()) + { + if(!arguments.eventSource) + { + arguments.eventSource=composition; + } + GuiGraphicsEventReceiver* eventReceiver=composition->GetEventReceiver(); + (eventReceiver->*eventReceiverEvent).Execute(arguments); + if(arguments.handled) + { + break; + } + } + + GuiGraphicsComposition* parent=composition->GetParent(); + if(parent) + { + Rect parentBounds=parent->GetBounds(); + Rect clientArea=parent->GetClientArea(); + Rect childBounds=composition->GetBounds(); + + x+=childBounds.x1+(clientArea.x1-parentBounds.x1); + y+=childBounds.y1+(clientArea.y1-parentBounds.y1); + arguments.x=x; + arguments.y=y; + } + composition=parent; + } + } + + void GuiGraphicsHost::OnMouseInput(const NativeWindowMouseInfo& info, GuiMouseEvent GuiGraphicsEventReceiver::* eventReceiverEvent) + { + GuiGraphicsComposition* composition=0; + if(mouseCaptureComposition) + { + composition=mouseCaptureComposition; + } + else + { + composition=windowComposition->FindComposition(Point(info.x, info.y), true); + } + if(composition) + { + Rect bounds=composition->GetGlobalBounds(); + GuiMouseEventArgs arguments; + (NativeWindowMouseInfo&)arguments=info; + arguments.x-=bounds.x1; + arguments.y-=bounds.y1; + RaiseMouseEvent(arguments, composition, eventReceiverEvent); + } + } + + INativeWindowListener::HitTestResult GuiGraphicsHost::HitTest(Point location) + { + Rect bounds = hostRecord.nativeWindow->GetBounds(); + Rect clientBounds = hostRecord.nativeWindow->GetClientBoundsInScreen(); + Point clientLocation(location.x + bounds.x1 - clientBounds.x1, location.y + bounds.y1 - clientBounds.y1); + GuiGraphicsComposition* hitComposition = windowComposition->FindComposition(clientLocation, false); + while (hitComposition) + { + INativeWindowListener::HitTestResult result = hitComposition->GetAssociatedHitTestResult(); + if (result == INativeWindowListener::NoDecision) + { + hitComposition = hitComposition->GetParent(); + } + else + { + return result; + } + } + return INativeWindowListener::NoDecision; + } + + void GuiGraphicsHost::Moving(Rect& bounds, bool fixSizeOnly) + { + Rect oldBounds = hostRecord.nativeWindow->GetBounds(); + minSize = windowComposition->GetPreferredBounds().GetSize(); + Size minWindowSize = minSize + (oldBounds.GetSize() - hostRecord.nativeWindow->GetClientSize()); + if (bounds.Width() < minWindowSize.x) + { + if (fixSizeOnly) + { + if (bounds.Width() < minWindowSize.x) + { + bounds.x2 = bounds.x1 + minWindowSize.x; + } + } + else if (oldBounds.x1 != bounds.x1) + { + bounds.x1 = oldBounds.x2 - minWindowSize.x; + } + else if (oldBounds.x2 != bounds.x2) + { + bounds.x2 = oldBounds.x1 + minWindowSize.x; + } + } + if (bounds.Height() < minWindowSize.y) + { + if (fixSizeOnly) + { + if (bounds.Height() < minWindowSize.y) + { + bounds.y2 = bounds.y1 + minWindowSize.y; + } + } + else if (oldBounds.y1 != bounds.y1) + { + bounds.y1 = oldBounds.y2 - minWindowSize.y; + } + else if (oldBounds.y2 != bounds.y2) + { + bounds.y2 = oldBounds.y1 + minWindowSize.y; + } + } + } + + void GuiGraphicsHost::Moved() + { + Size size = hostRecord.nativeWindow->GetClientSize(); + if (previousClientSize != size) + { + previousClientSize = size; + minSize = windowComposition->GetPreferredBounds().GetSize(); + needRender = true; + } + } + + void GuiGraphicsHost::Paint() + { + if (!supressPaint) + { + needRender = true; + } + } + + void GuiGraphicsHost::LeftButtonDown(const NativeWindowMouseInfo& info) + { + CloseAltHost(); + MouseCapture(info); + OnMouseInput(info, &GuiGraphicsEventReceiver::leftButtonDown); + } + + void GuiGraphicsHost::LeftButtonUp(const NativeWindowMouseInfo& info) + { + OnMouseInput(info, &GuiGraphicsEventReceiver::leftButtonUp); + MouseUncapture(info); + } + + void GuiGraphicsHost::LeftButtonDoubleClick(const NativeWindowMouseInfo& info) + { + LeftButtonDown(info); + OnMouseInput(info, &GuiGraphicsEventReceiver::leftButtonDoubleClick); + } + + void GuiGraphicsHost::RightButtonDown(const NativeWindowMouseInfo& info) + { + CloseAltHost(); + MouseCapture(info); + OnMouseInput(info, &GuiGraphicsEventReceiver::rightButtonDown); + } + + void GuiGraphicsHost::RightButtonUp(const NativeWindowMouseInfo& info) + { + OnMouseInput(info, &GuiGraphicsEventReceiver::rightButtonUp); + MouseUncapture(info); + } + + void GuiGraphicsHost::RightButtonDoubleClick(const NativeWindowMouseInfo& info) + { + RightButtonDown(info); + OnMouseInput(info, &GuiGraphicsEventReceiver::rightButtonDoubleClick); + } + + void GuiGraphicsHost::MiddleButtonDown(const NativeWindowMouseInfo& info) + { + CloseAltHost(); + MouseCapture(info); + OnMouseInput(info, &GuiGraphicsEventReceiver::middleButtonDown); + } + + void GuiGraphicsHost::MiddleButtonUp(const NativeWindowMouseInfo& info) + { + OnMouseInput(info, &GuiGraphicsEventReceiver::middleButtonUp); + MouseUncapture(info); + } + + void GuiGraphicsHost::MiddleButtonDoubleClick(const NativeWindowMouseInfo& info) + { + MiddleButtonDown(info); + OnMouseInput(info, &GuiGraphicsEventReceiver::middleButtonDoubleClick); + } + + void GuiGraphicsHost::HorizontalWheel(const NativeWindowMouseInfo& info) + { + OnMouseInput(info, &GuiGraphicsEventReceiver::horizontalWheel); + } + + void GuiGraphicsHost::VerticalWheel(const NativeWindowMouseInfo& info) + { + OnMouseInput(info, &GuiGraphicsEventReceiver::verticalWheel); + } + + void GuiGraphicsHost::MouseMoving(const NativeWindowMouseInfo& info) + { + CompositionList newCompositions; + { + GuiGraphicsComposition* composition = windowComposition->FindComposition(Point(info.x, info.y), true); + while (composition) + { + newCompositions.Insert(0, composition); + composition = composition->GetParent(); + } + } + + vint firstDifferentIndex = mouseEnterCompositions.Count(); + for (vint i = 0; i < mouseEnterCompositions.Count(); i++) + { + if (i == newCompositions.Count()) + { + firstDifferentIndex = newCompositions.Count(); + break; + } + if (mouseEnterCompositions[i] != newCompositions[i]) + { + firstDifferentIndex = i; + break; + } + } + + for (vint i = mouseEnterCompositions.Count() - 1; i >= firstDifferentIndex; i--) + { + GuiGraphicsComposition* composition = mouseEnterCompositions[i]; + if (composition->HasEventReceiver()) + { + composition->GetEventReceiver()->mouseLeave.Execute(GuiEventArgs(composition)); + } + } + + CopyFrom(mouseEnterCompositions, newCompositions); + for (vint i = firstDifferentIndex; i < mouseEnterCompositions.Count(); i++) + { + GuiGraphicsComposition* composition = mouseEnterCompositions[i]; + if (composition->HasEventReceiver()) + { + composition->GetEventReceiver()->mouseEnter.Execute(GuiEventArgs(composition)); + } + } + + INativeCursor* cursor = 0; + if (newCompositions.Count() > 0) + { + cursor = newCompositions[newCompositions.Count() - 1]->GetRelatedCursor(); + } + if (cursor) + { + hostRecord.nativeWindow->SetWindowCursor(cursor); + } + else + { + hostRecord.nativeWindow->SetWindowCursor(GetCurrentController()->ResourceService()->GetDefaultSystemCursor()); + } + + OnMouseInput(info, &GuiGraphicsEventReceiver::mouseMove); + } + + void GuiGraphicsHost::MouseEntered() + { + } + + void GuiGraphicsHost::MouseLeaved() + { + for(vint i=mouseEnterCompositions.Count()-1;i>=0;i--) + { + GuiGraphicsComposition* composition=mouseEnterCompositions[i]; + if(composition->HasEventReceiver()) + { + composition->GetEventReceiver()->mouseLeave.Execute(GuiEventArgs(composition)); + } + } + mouseEnterCompositions.Clear(); + } + + void GuiGraphicsHost::KeyDown(const NativeWindowKeyInfo& info) + { + if (!info.ctrl && !info.shift && currentAltHost) + { + if (info.code == VKEY_ESCAPE) + { + LeaveAltHost(); + return; + } + else if (info.code == VKEY_BACK) + { + LeaveAltKey(); + } + else if (VKEY_NUMPAD0 <= info.code && info.code <= VKEY_NUMPAD9) + { + if (EnterAltKey((wchar_t)(L'0' + (info.code - VKEY_NUMPAD0)))) + { + supressAltKey = info.code; + return; + } + } + else if (('0' <= info.code && info.code <= '9') || ('A' <= info.code && info.code <= 'Z')) + { + if (EnterAltKey((wchar_t)info.code)) + { + supressAltKey = info.code; + return; + } + } + } + + if (currentAltHost) + { + return; + } + + if(shortcutKeyManager && shortcutKeyManager->Execute(info)) + { + return; + } + if(focusedComposition && focusedComposition->HasEventReceiver()) + { + OnKeyInput(info, focusedComposition, &GuiGraphicsEventReceiver::keyDown); + } + } + + void GuiGraphicsHost::KeyUp(const NativeWindowKeyInfo& info) + { + if (!info.ctrl && !info.shift && info.code == supressAltKey) + { + supressAltKey = 0; + return; + } + + if(focusedComposition && focusedComposition->HasEventReceiver()) + { + OnKeyInput(info, focusedComposition, &GuiGraphicsEventReceiver::keyUp); + } + } + + void GuiGraphicsHost::SysKeyDown(const NativeWindowKeyInfo& info) + { + if (!info.ctrl && !info.shift && info.code == VKEY_MENU && !currentAltHost) + { + if (auto window = dynamic_cast(windowComposition->Children()[0]->GetRelatedControlHost())) + { + if (auto altHost = window->QueryTypedService()) + { + if (!altHost->GetPreviousAltHost()) + { + EnterAltHost(altHost); + } + } + } + } + + if (currentAltHost) + { + return; + } + + if(focusedComposition && focusedComposition->HasEventReceiver()) + { + OnKeyInput(info, focusedComposition, &GuiGraphicsEventReceiver::systemKeyDown); + } + } + + void GuiGraphicsHost::SysKeyUp(const NativeWindowKeyInfo& info) + { + if (!info.ctrl && !info.shift && info.code == VKEY_MENU && hostRecord.nativeWindow) + { + if (hostRecord.nativeWindow) + { + hostRecord.nativeWindow->SupressAlt(); + } + } + + if (focusedComposition && focusedComposition->HasEventReceiver()) + { + OnKeyInput(info, focusedComposition, &GuiGraphicsEventReceiver::systemKeyUp); + } + } + + void GuiGraphicsHost::Char(const NativeWindowCharInfo& info) + { + if (!currentAltHost && !supressAltKey) + { + if(focusedComposition && focusedComposition->HasEventReceiver()) + { + OnCharInput(info, focusedComposition, &GuiGraphicsEventReceiver::charInput); + } + } + } + + void GuiGraphicsHost::GlobalTimer() + { + if(animationManager.HasAnimation()) + { + animationManager.Play(); + } + + DateTime now=DateTime::UtcTime(); + if(now.totalMilliseconds-lastCaretTime>=CaretInterval) + { + lastCaretTime=now.totalMilliseconds; + if(focusedComposition && focusedComposition->HasEventReceiver()) + { + focusedComposition->GetEventReceiver()->caretNotify.Execute(GuiEventArgs(focusedComposition)); + } + } + + Render(false); + } + + GuiGraphicsHost::GuiGraphicsHost() + :shortcutKeyManager(0) + ,windowComposition(0) + ,focusedComposition(0) + ,mouseCaptureComposition(0) + ,lastCaretTime(0) + ,currentAltHost(0) + ,supressAltKey(0) + { + hostRecord.host = this; + windowComposition=new GuiWindowComposition; + windowComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + RefreshRelatedHostRecord(nullptr); + } + + GuiGraphicsHost::~GuiGraphicsHost() + { + NotifyFinalizeInstance(windowComposition); + if(shortcutKeyManager) + { + delete shortcutKeyManager; + shortcutKeyManager=0; + } + delete windowComposition; + } + + INativeWindow* GuiGraphicsHost::GetNativeWindow() + { + return hostRecord.nativeWindow; + } + + void GuiGraphicsHost::SetNativeWindow(INativeWindow* _nativeWindow) + { + if (hostRecord.nativeWindow != _nativeWindow) + { + if (hostRecord.nativeWindow) + { + GetCurrentController()->CallbackService()->UninstallListener(this); + hostRecord.nativeWindow->UninstallListener(this); + } + + if (_nativeWindow) + { + _nativeWindow->InstallListener(this); + GetCurrentController()->CallbackService()->InstallListener(this); + previousClientSize = _nativeWindow->GetClientSize(); + minSize = windowComposition->GetPreferredBounds().GetSize(); + _nativeWindow->SetCaretPoint(caretPoint); + needRender = true; + } + + RefreshRelatedHostRecord(_nativeWindow); + } + } + + GuiGraphicsComposition* GuiGraphicsHost::GetMainComposition() + { + return windowComposition; + } + + void GuiGraphicsHost::Render(bool forceUpdate) + { + if (!forceUpdate && !needRender) + { + return; + } + needRender = false; + + if(hostRecord.nativeWindow && hostRecord.nativeWindow->IsVisible()) + { + supressPaint = true; + hostRecord.renderTarget->StartRendering(); + windowComposition->Render(Size()); + auto result = hostRecord.renderTarget->StopRendering(); + hostRecord.nativeWindow->RedrawContent(); + supressPaint = false; + + switch (result) + { + case RenderTargetFailure::ResizeWhileRendering: + { + GetGuiGraphicsResourceManager()->ResizeRenderTarget(hostRecord.nativeWindow); + needRender = true; + } + break; + case RenderTargetFailure::LostDevice: + { + windowComposition->UpdateRelatedHostRecord(nullptr); + GetGuiGraphicsResourceManager()->RecreateRenderTarget(hostRecord.nativeWindow); + RefreshRelatedHostRecord(hostRecord.nativeWindow); + needRender = true; + } + break; + default:; + } + } + } + + void GuiGraphicsHost::RequestRender() + { + needRender = true; + } + + IGuiShortcutKeyManager* GuiGraphicsHost::GetShortcutKeyManager() + { + return shortcutKeyManager; + } + + void GuiGraphicsHost::SetShortcutKeyManager(IGuiShortcutKeyManager* value) + { + shortcutKeyManager=value; + } + + bool GuiGraphicsHost::SetFocus(GuiGraphicsComposition* composition) + { + if(!composition || composition->GetRelatedGraphicsHost()!=this) + { + return false; + } + if(focusedComposition && focusedComposition->HasEventReceiver()) + { + GuiEventArgs arguments; + arguments.compositionSource=focusedComposition; + arguments.eventSource=focusedComposition; + focusedComposition->GetEventReceiver()->lostFocus.Execute(arguments); + } + focusedComposition=composition; + SetCaretPoint(Point(0, 0)); + if(focusedComposition && focusedComposition->HasEventReceiver()) + { + GuiEventArgs arguments; + arguments.compositionSource=focusedComposition; + arguments.eventSource=focusedComposition; + focusedComposition->GetEventReceiver()->gotFocus.Execute(arguments); + } + return true; + } + + GuiGraphicsComposition* GuiGraphicsHost::GetFocusedComposition() + { + return focusedComposition; + } + + Point GuiGraphicsHost::GetCaretPoint() + { + return caretPoint; + } + + void GuiGraphicsHost::SetCaretPoint(Point value, GuiGraphicsComposition* referenceComposition) + { + if (referenceComposition) + { + Rect bounds = referenceComposition->GetGlobalBounds(); + value.x += bounds.x1; + value.y += bounds.y1; + } + caretPoint = value; + if (hostRecord.nativeWindow) + { + hostRecord.nativeWindow->SetCaretPoint(caretPoint); + } + } + + GuiGraphicsAnimationManager* GuiGraphicsHost::GetAnimationManager() + { + return &animationManager; + } + + void GuiGraphicsHost::DisconnectComposition(GuiGraphicsComposition* composition) + { + DisconnectCompositionInternal(composition); + } + +/*********************************************************************** +GuiTimeBasedAnimation +***********************************************************************/ + + GuiTimeBasedAnimation::GuiTimeBasedAnimation(vint totalMilliseconds) + :startTime(0) + ,length(totalMilliseconds) + { + Restart(); + } + + GuiTimeBasedAnimation::~GuiTimeBasedAnimation() + { + } + + void GuiTimeBasedAnimation::Restart(vint totalMilliseconds) + { + startTime=DateTime::LocalTime().totalMilliseconds; + if(totalMilliseconds>-1) + { + length=totalMilliseconds; + } + } + + vint GuiTimeBasedAnimation::GetTotalLength() + { + return length; + } + + vint GuiTimeBasedAnimation::GetCurrentPosition() + { + return (vint)(DateTime::LocalTime().totalMilliseconds-startTime); + } + +/*********************************************************************** +GuiShortcutKeyItem +***********************************************************************/ + + GuiShortcutKeyItem::GuiShortcutKeyItem(GuiShortcutKeyManager* _shortcutKeyManager, bool _ctrl, bool _shift, bool _alt, vint _key) + :shortcutKeyManager(_shortcutKeyManager) + ,ctrl(_ctrl) + ,shift(_shift) + ,alt(_alt) + ,key(_key) + { + } + + GuiShortcutKeyItem::~GuiShortcutKeyItem() + { + } + + IGuiShortcutKeyManager* GuiShortcutKeyItem::GetManager() + { + return shortcutKeyManager; + } + + WString GuiShortcutKeyItem::GetName() + { + WString name; + if(ctrl) name+=L"Ctrl+"; + if(shift) name+=L"Shift+"; + if(alt) name+=L"Alt+"; + name+=GetCurrentController()->InputService()->GetKeyName(key); + return name; + } + + bool GuiShortcutKeyItem::CanActivate(const NativeWindowKeyInfo& info) + { + return + info.ctrl==ctrl && + info.shift==shift && + info.alt==alt && + info.code==key; + } + + bool GuiShortcutKeyItem::CanActivate(bool _ctrl, bool _shift, bool _alt, vint _key) + { + return + _ctrl==ctrl && + _shift==shift && + _alt==alt && + _key==key; + } + +/*********************************************************************** +GuiShortcutKeyManager +***********************************************************************/ + + GuiShortcutKeyManager::GuiShortcutKeyManager() + { + } + + GuiShortcutKeyManager::~GuiShortcutKeyManager() + { + } + + vint GuiShortcutKeyManager::GetItemCount() + { + return shortcutKeyItems.Count(); + } + + IGuiShortcutKeyItem* GuiShortcutKeyManager::GetItem(vint index) + { + return shortcutKeyItems[index].Obj(); + } + + bool GuiShortcutKeyManager::Execute(const NativeWindowKeyInfo& info) + { + bool executed=false; + FOREACH(Ptr, item, shortcutKeyItems) + { + if(item->CanActivate(info)) + { + GuiEventArgs arguments; + item->Executed.Execute(arguments); + executed=true; + } + } + return executed; + } + + IGuiShortcutKeyItem* GuiShortcutKeyManager::CreateShortcut(bool ctrl, bool shift, bool alt, vint key) + { + FOREACH(Ptr, item, shortcutKeyItems) + { + if(item->CanActivate(ctrl, shift, alt, key)) + { + return item.Obj(); + } + } + Ptr item=new GuiShortcutKeyItem(this, ctrl, shift, alt, key); + shortcutKeyItems.Add(item); + return item.Obj(); + } + + bool GuiShortcutKeyManager::DestroyShortcut(bool ctrl, bool shift, bool alt, vint key) + { + FOREACH(Ptr, item, shortcutKeyItems) + { + if(item->CanActivate(ctrl, shift, alt, key)) + { + shortcutKeyItems.Remove(item.Obj()); + return true; + } + } + return false; + } + + IGuiShortcutKeyItem* GuiShortcutKeyManager::TryGetShortcut(bool ctrl, bool shift, bool alt, vint key) + { + FOREACH(Ptr, item, shortcutKeyItems) + { + if(item->CanActivate(ctrl, shift, alt, key)) + { + return item.Obj(); + } + } + return 0; + } + } + } +} + /*********************************************************************** .\CONTROLS\GUIBUTTONCONTROLS.CPP ***********************************************************************/ @@ -8810,6 +11188,479 @@ GuiSelectableButton } } +/*********************************************************************** +.\CONTROLS\GUICONTAINERCONTROLS.CPP +***********************************************************************/ + + +namespace vl +{ + namespace presentation + { + using namespace compositions; + + namespace controls + { + +/*********************************************************************** +GuiTabPage +***********************************************************************/ + + bool GuiTabPage::IsAltAvailable() + { + return false; + } + + GuiTabPage::GuiTabPage(theme::ThemeName themeName) + :GuiCustomControl(themeName) + { + } + + GuiTabPage::~GuiTabPage() + { + FinalizeAggregation(); + } + + GuiTab* GuiTabPage::GetOwnerTab() + { + return tab; + } + +/*********************************************************************** +GuiTabPageList +***********************************************************************/ + + bool GuiTabPageList::QueryInsert(vint index, GuiTabPage* const& value) + { + return !items.Contains(value) && value->tab == nullptr; + } + + void GuiTabPageList::AfterInsert(vint index, GuiTabPage* const& value) + { + value->tab = tab; + value->SetVisible(false); + value->boundsComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + tab->containerComposition->AddChild(value->boundsComposition); + + if (!tab->selectedPage) + { + tab->SetSelectedPage(value); + } + } + + void GuiTabPageList::BeforeRemove(vint index, GuiTabPage* const& value) + { + tab->containerComposition->RemoveChild(value->boundsComposition); + value->tab = nullptr; + + if (items.Count() == 0) + { + tab->SetSelectedPage(nullptr); + } + else if (tab->selectedPage == value) + { + tab->SetSelectedPage(items[0]); + } + } + + GuiTabPageList::GuiTabPageList(GuiTab* _tab) + :tab(_tab) + { + } + + GuiTabPageList::~GuiTabPageList() + { + } + +/*********************************************************************** +GuiTab +***********************************************************************/ + + void GuiTab::BeforeControlTemplateUninstalled_() + { + auto ct = GetControlTemplateObject(); + ct->SetCommands(nullptr); + ct->SetTabPages(nullptr); + ct->SetSelectedTabPage(nullptr); + } + + void GuiTab::AfterControlTemplateInstalled_(bool initialize) + { + auto ct = GetControlTemplateObject(); + ct->SetCommands(commandExecutor.Obj()); + ct->SetTabPages(tabPages.GetWrapper()); + ct->SetSelectedTabPage(selectedPage); + } + + GuiTab::CommandExecutor::CommandExecutor(GuiTab* _tab) + :tab(_tab) + { + } + + GuiTab::CommandExecutor::~CommandExecutor() + { + } + + void GuiTab::CommandExecutor::ShowTab(vint index) + { + tab->SetSelectedPage(tab->GetPages().Get(index)); + } + + GuiTab::GuiTab(theme::ThemeName themeName) + :GuiControl(themeName) + , tabPages(this) + { + commandExecutor = new CommandExecutor(this); + } + + GuiTab::~GuiTab() + { + } + + collections::ObservableList& GuiTab::GetPages() + { + return tabPages; + } + + GuiTabPage* GuiTab::GetSelectedPage() + { + return selectedPage; + } + + bool GuiTab::SetSelectedPage(GuiTabPage* value) + { + if (!value) + { + if (tabPages.Count() == 0) + { + selectedPage = nullptr; + } + } + else if (value->GetOwnerTab() == this) + { + if (selectedPage == value) + { + return true; + } + + selectedPage = value; + FOREACH(GuiTabPage*, tabPage, tabPages) + { + tabPage->SetVisible(tabPage == selectedPage); + } + } + if (HasControlTemplateObject()) + { + GetControlTemplateObject()->SetSelectedTabPage(selectedPage); + } + SelectedPageChanged.Execute(GetNotifyEventArguments()); + return selectedPage == value; + } + +/*********************************************************************** +GuiScrollView +***********************************************************************/ + + void GuiScrollView::BeforeControlTemplateUninstalled_() + { + auto ct = GetControlTemplateObject(); + ct->GetHorizontalScroll()->PositionChanged.Detach(hScrollHandler); + ct->GetVerticalScroll()->PositionChanged.Detach(vScrollHandler); + ct->GetEventReceiver()->horizontalWheel.Detach(hWheelHandler); + ct->GetEventReceiver()->verticalWheel.Detach(vWheelHandler); + + hScrollHandler = nullptr; + vScrollHandler = nullptr; + hWheelHandler = nullptr; + vWheelHandler = nullptr; + supressScrolling = false; + } + + void GuiScrollView::AfterControlTemplateInstalled_(bool initialize) + { + auto ct = GetControlTemplateObject(); + hScrollHandler = ct->GetHorizontalScroll()->PositionChanged.AttachMethod(this, &GuiScrollView::OnHorizontalScroll); + vScrollHandler = ct->GetVerticalScroll()->PositionChanged.AttachMethod(this, &GuiScrollView::OnVerticalScroll); + hWheelHandler = ct->GetEventReceiver()->horizontalWheel.AttachMethod(this, &GuiScrollView::OnHorizontalWheel); + vWheelHandler = ct->GetEventReceiver()->verticalWheel.AttachMethod(this, &GuiScrollView::OnVerticalWheel); + CalculateView(); + } + + void GuiScrollView::OnContainerBoundsChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + CalculateView(); + } + + void GuiScrollView::OnHorizontalScroll(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if(!supressScrolling) + { + CallUpdateView(); + } + } + + void GuiScrollView::OnVerticalScroll(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if(!supressScrolling) + { + CallUpdateView(); + } + } + + void GuiScrollView::OnHorizontalWheel(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) + { + if(!supressScrolling) + { + auto scroll = GetControlTemplateObject()->GetHorizontalScroll(); + vint position = scroll->GetPosition(); + vint move = scroll->GetSmallMove(); + position -= move*arguments.wheel / 60; + scroll->SetPosition(position); + } + } + + void GuiScrollView::OnVerticalWheel(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) + { + if(!supressScrolling && GetVisuallyEnabled()) + { + auto scroll = GetControlTemplateObject()->GetVerticalScroll(); + vint position = scroll->GetPosition(); + vint move = scroll->GetSmallMove(); + position -= move*arguments.wheel / 60; + scroll->SetPosition(position); + } + } + + void GuiScrollView::CallUpdateView() + { + Rect viewBounds=GetViewBounds(); + UpdateView(viewBounds); + } + + void GuiScrollView::AdjustView(Size fullSize) + { + auto ct = GetControlTemplateObject(); + auto hScroll = ct->GetHorizontalScroll(); + auto vScroll = ct->GetVerticalScroll(); + + Size viewSize = ct->GetContainerComposition()->GetBounds().GetSize(); + if (fullSize.x <= viewSize.x) + { + hScroll->SetVisible(horizontalAlwaysVisible); + hScroll->SetEnabled(false); + hScroll->SetPosition(0); + } + else + { + hScroll->SetVisible(true); + hScroll->SetEnabled(true); + hScroll->SetTotalSize(fullSize.x); + hScroll->SetPageSize(viewSize.x); + } + + if (fullSize.y <= viewSize.y) + { + vScroll->SetVisible(verticalAlwaysVisible); + vScroll->SetEnabled(false); + vScroll->SetPosition(0); + } + else + { + vScroll->SetVisible(true); + vScroll->SetEnabled(true); + vScroll->SetTotalSize(fullSize.y); + vScroll->SetPageSize(viewSize.y); + } + } + + GuiScrollView::GuiScrollView(theme::ThemeName themeName) + :GuiControl(themeName) + { + containerComposition->BoundsChanged.AttachMethod(this, &GuiScrollView::OnContainerBoundsChanged); + } + + vint GuiScrollView::GetSmallMove() + { + return GetFont().size * 2; + } + + Size GuiScrollView::GetBigMove() + { + return GetViewSize(); + } + + GuiScrollView::~GuiScrollView() + { + } + + void GuiScrollView::SetFont(const FontProperties& value) + { + GuiControl::SetFont(value); + CalculateView(); + } + + void GuiScrollView::CalculateView() + { + auto ct = GetControlTemplateObject(); + if(!supressScrolling) + { + Size fullSize = QueryFullSize(); + while(true) + { + AdjustView(fullSize); + AdjustView(fullSize); + supressScrolling = true; + CallUpdateView(); + supressScrolling = false; + + Size newSize=QueryFullSize(); + if (fullSize == newSize) + { + vint smallMove = GetSmallMove(); + ct->GetHorizontalScroll()->SetSmallMove(smallMove); + ct->GetVerticalScroll()->SetSmallMove(smallMove); + Size bigMove = GetBigMove(); + ct->GetHorizontalScroll()->SetBigMove(bigMove.x); + ct->GetVerticalScroll()->SetBigMove(bigMove.y); + break; + } + else + { + fullSize=newSize; + } + } + } + } + + Size GuiScrollView::GetViewSize() + { + Size viewSize = GetControlTemplateObject()->GetContainerComposition()->GetBounds().GetSize(); + return viewSize; + } + + Rect GuiScrollView::GetViewBounds() + { + auto ct = GetControlTemplateObject(); + Point viewPosition= + Point( + ct->GetHorizontalScroll()->GetPosition(), + ct->GetVerticalScroll()->GetPosition() + ); + Size viewSize=GetViewSize(); + return Rect(viewPosition, viewSize); + } + + GuiScroll* GuiScrollView::GetHorizontalScroll() + { + return GetControlTemplateObject()->GetHorizontalScroll(); + } + + GuiScroll* GuiScrollView::GetVerticalScroll() + { + return GetControlTemplateObject()->GetVerticalScroll(); + } + + bool GuiScrollView::GetHorizontalAlwaysVisible() + { + return horizontalAlwaysVisible; + } + + void GuiScrollView::SetHorizontalAlwaysVisible(bool value) + { + if (horizontalAlwaysVisible != value) + { + horizontalAlwaysVisible = value; + CalculateView(); + } + } + + bool GuiScrollView::GetVerticalAlwaysVisible() + { + return verticalAlwaysVisible; + } + + void GuiScrollView::SetVerticalAlwaysVisible(bool value) + { + if (verticalAlwaysVisible != value) + { + verticalAlwaysVisible = value; + CalculateView(); + } + } + +/*********************************************************************** +GuiScrollContainer +***********************************************************************/ + + Size GuiScrollContainer::QueryFullSize() + { + return containerComposition->GetBounds().GetSize(); + } + + void GuiScrollContainer::UpdateView(Rect viewBounds) + { + auto leftTop = Point(-viewBounds.x1, -viewBounds.y1); + containerComposition->SetBounds(Rect(leftTop, Size(0, 0))); + } + + GuiScrollContainer::GuiScrollContainer(theme::ThemeName themeName) + :GuiScrollView(themeName) + { + containerComposition->SetAlignmentToParent(Margin(-1, -1, -1, -1)); + UpdateView(Rect(0, 0, 0, 0)); + } + + GuiScrollContainer::~GuiScrollContainer() + { + } + + bool GuiScrollContainer::GetExtendToFullWidth() + { + return extendToFullWidth; + } + + void GuiScrollContainer::SetExtendToFullWidth(bool value) + { + if (extendToFullWidth != value) + { + extendToFullWidth = value; + auto margin = containerComposition->GetAlignmentToParent(); + if (value) + { + containerComposition->SetAlignmentToParent(Margin(0, margin.top, 0, margin.bottom)); + } + else + { + containerComposition->SetAlignmentToParent(Margin(-1, margin.top, -1, margin.bottom)); + } + } + } + + bool GuiScrollContainer::GetExtendToFullHeight() + { + return extendToFullHeight; + } + + void GuiScrollContainer::SetExtendToFullHeight(bool value) + { + if (extendToFullHeight != value) + { + extendToFullHeight = value; + auto margin = containerComposition->GetAlignmentToParent(); + if (value) + { + containerComposition->SetAlignmentToParent(Margin(margin.left, 0, margin.right, 0)); + } + else + { + containerComposition->SetAlignmentToParent(Margin(margin.left, -1, margin.right, -1)); + } + } + } + } + } +} + /*********************************************************************** .\CONTROLS\GUISCROLLCONTROLS.CPP ***********************************************************************/ @@ -9011,960 +11862,6 @@ GuiScroll } } -/*********************************************************************** -.\CONTROLS\GUICONTAINERCONTROLS.CPP -***********************************************************************/ - - -namespace vl -{ - namespace presentation - { - using namespace compositions; - - namespace controls - { - -/*********************************************************************** -GuiTabPage -***********************************************************************/ - - bool GuiTabPage::IsAltAvailable() - { - return false; - } - - GuiTabPage::GuiTabPage(theme::ThemeName themeName) - :GuiCustomControl(themeName) - { - } - - GuiTabPage::~GuiTabPage() - { - FinalizeAggregation(); - } - - GuiTab* GuiTabPage::GetOwnerTab() - { - return tab; - } - -/*********************************************************************** -GuiTabPageList -***********************************************************************/ - - bool GuiTabPageList::QueryInsert(vint index, GuiTabPage* const& value) - { - return !items.Contains(value) && value->tab == nullptr; - } - - void GuiTabPageList::AfterInsert(vint index, GuiTabPage* const& value) - { - value->tab = tab; - value->SetVisible(false); - value->boundsComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); - tab->containerComposition->AddChild(value->boundsComposition); - - if (!tab->selectedPage) - { - tab->SetSelectedPage(value); - } - } - - void GuiTabPageList::BeforeRemove(vint index, GuiTabPage* const& value) - { - tab->containerComposition->RemoveChild(value->boundsComposition); - value->tab = nullptr; - - if (items.Count() == 0) - { - tab->SetSelectedPage(nullptr); - } - else if (tab->selectedPage == value) - { - tab->SetSelectedPage(items[0]); - } - } - - GuiTabPageList::GuiTabPageList(GuiTab* _tab) - :tab(_tab) - { - } - - GuiTabPageList::~GuiTabPageList() - { - } - -/*********************************************************************** -GuiTab -***********************************************************************/ - - void GuiTab::BeforeControlTemplateUninstalled_() - { - auto ct = GetControlTemplateObject(); - ct->SetCommands(nullptr); - ct->SetTabPages(nullptr); - ct->SetSelectedTabPage(nullptr); - } - - void GuiTab::AfterControlTemplateInstalled_(bool initialize) - { - auto ct = GetControlTemplateObject(); - ct->SetCommands(commandExecutor.Obj()); - ct->SetTabPages(tabPages.GetWrapper()); - ct->SetSelectedTabPage(selectedPage); - } - - GuiTab::CommandExecutor::CommandExecutor(GuiTab* _tab) - :tab(_tab) - { - } - - GuiTab::CommandExecutor::~CommandExecutor() - { - } - - void GuiTab::CommandExecutor::ShowTab(vint index) - { - tab->SetSelectedPage(tab->GetPages().Get(index)); - } - - GuiTab::GuiTab(theme::ThemeName themeName) - :GuiControl(themeName) - , tabPages(this) - { - commandExecutor = new CommandExecutor(this); - } - - GuiTab::~GuiTab() - { - } - - collections::ObservableList& GuiTab::GetPages() - { - return tabPages; - } - - GuiTabPage* GuiTab::GetSelectedPage() - { - return selectedPage; - } - - bool GuiTab::SetSelectedPage(GuiTabPage* value) - { - if (!value) - { - if (tabPages.Count() == 0) - { - selectedPage = nullptr; - } - } - else if (value->GetOwnerTab() == this) - { - if (selectedPage == value) - { - return true; - } - - selectedPage = value; - FOREACH(GuiTabPage*, tabPage, tabPages) - { - tabPage->SetVisible(tabPage == selectedPage); - } - } - if (HasControlTemplateObject()) - { - GetControlTemplateObject()->SetSelectedTabPage(selectedPage); - } - SelectedPageChanged.Execute(GetNotifyEventArguments()); - return selectedPage == value; - } - -/*********************************************************************** -GuiScrollView::CommandExecutor -***********************************************************************/ - - GuiScrollView::CommandExecutor::CommandExecutor(GuiScrollView* _scrollView) - :scrollView(_scrollView) - { - } - - GuiScrollView::CommandExecutor::~CommandExecutor() - { - } - - void GuiScrollView::CommandExecutor::CalculateView() - { - scrollView->CalculateView(); - } - -/*********************************************************************** -GuiScrollView -***********************************************************************/ - - void GuiScrollView::BeforeControlTemplateUninstalled_() - { - auto ct = GetControlTemplateObject(); - ct->SetCommands(nullptr); - ct->GetHorizontalScroll()->PositionChanged.Detach(hScrollHandler); - ct->GetVerticalScroll()->PositionChanged.Detach(vScrollHandler); - ct->GetEventReceiver()->horizontalWheel.Detach(hWheelHandler); - ct->GetEventReceiver()->verticalWheel.Detach(vWheelHandler); - - hScrollHandler = nullptr; - vScrollHandler = nullptr; - hWheelHandler = nullptr; - vWheelHandler = nullptr; - supressScrolling = false; - } - - void GuiScrollView::AfterControlTemplateInstalled_(bool initialize) - { - auto ct = GetControlTemplateObject(); - ct->SetCommands(commandExecutor.Obj()); - hScrollHandler = ct->GetHorizontalScroll()->PositionChanged.AttachMethod(this, &GuiScrollView::OnHorizontalScroll); - vScrollHandler = ct->GetVerticalScroll()->PositionChanged.AttachMethod(this, &GuiScrollView::OnVerticalScroll); - hWheelHandler = ct->GetEventReceiver()->horizontalWheel.AttachMethod(this, &GuiScrollView::OnHorizontalWheel); - vWheelHandler = ct->GetEventReceiver()->verticalWheel.AttachMethod(this, &GuiScrollView::OnVerticalWheel); - - if (initialize) - { - horizontalAlwaysVisible = ct->GetHorizontalAlwaysVisible(); - verticalAlwaysVisible = ct->GetVerticalAlwaysVisible(); - } - else - { - ct->SetHorizontalAlwaysVisible(horizontalAlwaysVisible); - ct->SetVerticalAlwaysVisible(verticalAlwaysVisible); - } - CalculateView(); - } - - void GuiScrollView::OnContainerBoundsChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - CalculateView(); - } - - void GuiScrollView::OnHorizontalScroll(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if(!supressScrolling) - { - CallUpdateView(); - } - } - - void GuiScrollView::OnVerticalScroll(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if(!supressScrolling) - { - CallUpdateView(); - } - } - - void GuiScrollView::OnHorizontalWheel(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) - { - if(!supressScrolling) - { - auto scroll = GetControlTemplateObject()->GetHorizontalScroll(); - vint position = scroll->GetPosition(); - vint move = scroll->GetSmallMove(); - position -= move*arguments.wheel / 60; - scroll->SetPosition(position); - } - } - - void GuiScrollView::OnVerticalWheel(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) - { - if(!supressScrolling && GetVisuallyEnabled()) - { - auto scroll = GetControlTemplateObject()->GetVerticalScroll(); - vint position = scroll->GetPosition(); - vint move = scroll->GetSmallMove(); - position -= move*arguments.wheel / 60; - scroll->SetPosition(position); - } - } - - void GuiScrollView::CallUpdateView() - { - Rect viewBounds=GetViewBounds(); - UpdateView(viewBounds); - } - - GuiScrollView::GuiScrollView(theme::ThemeName themeName) - :GuiControl(themeName) - , supressScrolling(false) - { - commandExecutor = new CommandExecutor(this); - containerComposition->BoundsChanged.AttachMethod(this, &GuiScrollView::OnContainerBoundsChanged); - } - - vint GuiScrollView::GetSmallMove() - { - return GetFont().size * 2; - } - - Size GuiScrollView::GetBigMove() - { - return GetViewSize(); - } - - GuiScrollView::~GuiScrollView() - { - } - - void GuiScrollView::SetFont(const FontProperties& value) - { - GuiControl::SetFont(value); - CalculateView(); - } - - void GuiScrollView::CalculateView() - { - auto ct = GetControlTemplateObject(); - if(!supressScrolling) - { - Size fullSize = QueryFullSize(); - while(true) - { - ct->AdjustView(fullSize); - ct->AdjustView(fullSize); - supressScrolling = true; - CallUpdateView(); - supressScrolling = false; - - Size newSize=QueryFullSize(); - if (fullSize == newSize) - { - vint smallMove = GetSmallMove(); - ct->GetHorizontalScroll()->SetSmallMove(smallMove); - ct->GetVerticalScroll()->SetSmallMove(smallMove); - Size bigMove = GetBigMove(); - ct->GetHorizontalScroll()->SetBigMove(bigMove.x); - ct->GetVerticalScroll()->SetBigMove(bigMove.y); - break; - } - else - { - fullSize=newSize; - } - } - } - } - - Size GuiScrollView::GetViewSize() - { - Size viewSize = GetControlTemplateObject()->GetContainerComposition()->GetBounds().GetSize(); - return viewSize; - } - - Rect GuiScrollView::GetViewBounds() - { - auto ct = GetControlTemplateObject(); - Point viewPosition= - Point( - ct->GetHorizontalScroll()->GetPosition(), - ct->GetVerticalScroll()->GetPosition() - ); - Size viewSize=GetViewSize(); - return Rect(viewPosition, viewSize); - } - - GuiScroll* GuiScrollView::GetHorizontalScroll() - { - return GetControlTemplateObject()->GetHorizontalScroll(); - } - - GuiScroll* GuiScrollView::GetVerticalScroll() - { - return GetControlTemplateObject()->GetVerticalScroll(); - } - - bool GuiScrollView::GetHorizontalAlwaysVisible() - { - return horizontalAlwaysVisible; - } - - void GuiScrollView::SetHorizontalAlwaysVisible(bool value) - { - if (horizontalAlwaysVisible != value) - { - horizontalAlwaysVisible = value; - GetControlTemplateObject()->SetHorizontalAlwaysVisible(value); - } - } - - bool GuiScrollView::GetVerticalAlwaysVisible() - { - return verticalAlwaysVisible; - } - - void GuiScrollView::SetVerticalAlwaysVisible(bool value) - { - if (verticalAlwaysVisible != value) - { - verticalAlwaysVisible = value; - GetControlTemplateObject()->SetVerticalAlwaysVisible(value); - } - } - -/*********************************************************************** -GuiScrollContainer -***********************************************************************/ - - Size GuiScrollContainer::QueryFullSize() - { - return containerComposition->GetBounds().GetSize(); - } - - void GuiScrollContainer::UpdateView(Rect viewBounds) - { - auto leftTop = Point(-viewBounds.x1, -viewBounds.y1); - containerComposition->SetBounds(Rect(leftTop, Size(0, 0))); - } - - GuiScrollContainer::GuiScrollContainer(theme::ThemeName themeName) - :GuiScrollView(themeName) - { - containerComposition->SetAlignmentToParent(Margin(-1, -1, -1, -1)); - UpdateView(Rect(0, 0, 0, 0)); - } - - GuiScrollContainer::~GuiScrollContainer() - { - } - - bool GuiScrollContainer::GetExtendToFullWidth() - { - return extendToFullWidth; - } - - void GuiScrollContainer::SetExtendToFullWidth(bool value) - { - if (extendToFullWidth != value) - { - extendToFullWidth = value; - auto margin = containerComposition->GetAlignmentToParent(); - if (value) - { - containerComposition->SetAlignmentToParent(Margin(0, margin.top, 0, margin.bottom)); - } - else - { - containerComposition->SetAlignmentToParent(Margin(-1, margin.top, -1, margin.bottom)); - } - } - } - - bool GuiScrollContainer::GetExtendToFullHeight() - { - return extendToFullHeight; - } - - void GuiScrollContainer::SetExtendToFullHeight(bool value) - { - if (extendToFullHeight != value) - { - extendToFullHeight = value; - auto margin = containerComposition->GetAlignmentToParent(); - if (value) - { - containerComposition->SetAlignmentToParent(Margin(margin.left, 0, margin.right, 0)); - } - else - { - containerComposition->SetAlignmentToParent(Margin(margin.left, -1, margin.right, -1)); - } - } - } - } - } -} - -/*********************************************************************** -.\CONTROLS\GUIDIALOGS.CPP -***********************************************************************/ - -namespace vl -{ - namespace presentation - { - namespace controls - { - using namespace elements; - using namespace compositions; - using namespace collections; - using namespace reflection::description; - -/*********************************************************************** -GuiDialogBase -***********************************************************************/ - - GuiWindow* GuiDialogBase::GetHostWindow() - { - if (rootObject) - { - if (auto control = dynamic_cast(rootObject)) - { - if (auto host = control->GetRelatedControlHost()) - { - return dynamic_cast(host); - } - } - else if (auto composition = dynamic_cast(rootObject)) - { - if (auto host = composition->GetRelatedControlHost()) - { - return dynamic_cast(host); - } - } - } - return nullptr; - } - - GuiDialogBase::GuiDialogBase() - { - } - - GuiDialogBase::~GuiDialogBase() - { - } - - void GuiDialogBase::Attach(GuiInstanceRootObject* _rootObject) - { - rootObject = _rootObject; - } - - void GuiDialogBase::Detach(GuiInstanceRootObject* _rootObject) - { - rootObject = nullptr; - } - -/*********************************************************************** -GuiMessageDialog -***********************************************************************/ - - GuiMessageDialog::GuiMessageDialog() - { - } - - GuiMessageDialog::~GuiMessageDialog() - { - } - - INativeDialogService::MessageBoxButtonsInput GuiMessageDialog::GetInput() - { - return input; - } - - void GuiMessageDialog::SetInput(INativeDialogService::MessageBoxButtonsInput value) - { - input = value; - } - - INativeDialogService::MessageBoxDefaultButton GuiMessageDialog::GetDefaultButton() - { - return defaultButton; - } - - void GuiMessageDialog::SetDefaultButton(INativeDialogService::MessageBoxDefaultButton value) - { - defaultButton = value; - } - - INativeDialogService::MessageBoxIcons GuiMessageDialog::GetIcon() - { - return icon; - } - - void GuiMessageDialog::SetIcon(INativeDialogService::MessageBoxIcons value) - { - icon = value; - } - - INativeDialogService::MessageBoxModalOptions GuiMessageDialog::GetModalOption() - { - return modalOption; - } - - void GuiMessageDialog::SetModalOption(INativeDialogService::MessageBoxModalOptions value) - { - modalOption = value; - } - - const WString& GuiMessageDialog::GetText() - { - return text; - } - - void GuiMessageDialog::SetText(const WString& value) - { - text = value; - } - - const WString& GuiMessageDialog::GetTitle() - { - return title; - } - - void GuiMessageDialog::SetTitle(const WString& value) - { - title = value; - } - - INativeDialogService::MessageBoxButtonsOutput GuiMessageDialog::ShowDialog() - { - auto service = GetCurrentController()->DialogService(); - return service->ShowMessageBox(GetHostWindow()->GetNativeWindow(), text, title, input, defaultButton, icon, modalOption); - } - -/*********************************************************************** -GuiColorDialog -***********************************************************************/ - - GuiColorDialog::GuiColorDialog() - { - for (vint i = 0; i < 16; i++) - { - customColors.Add(Color()); - } - } - - GuiColorDialog::~GuiColorDialog() - { - } - - bool GuiColorDialog::GetEnabledCustomColor() - { - return enabledCustomColor; - } - - void GuiColorDialog::SetEnabledCustomColor(bool value) - { - enabledCustomColor = value; - } - - bool GuiColorDialog::GetOpenedCustomColor() - { - return openedCustomColor; - } - - void GuiColorDialog::SetOpenedCustomColor(bool value) - { - openedCustomColor = value; - } - - Color GuiColorDialog::GetSelectedColor() - { - return selectedColor; - } - - void GuiColorDialog::SetSelectedColor(Color value) - { - if (selectedColor != value) - { - selectedColor = value; - SelectedColorChanged.Execute(GuiEventArgs()); - } - } - - collections::List& GuiColorDialog::GetCustomColors() - { - return customColors; - } - - bool GuiColorDialog::ShowDialog() - { - Array colors; - CopyFrom(colors, customColors); - colors.Resize(16); - - INativeDialogService::ColorDialogCustomColorOptions options = - !enabledCustomColor ? INativeDialogService::CustomColorDisabled : - !openedCustomColor ? INativeDialogService::CustomColorEnabled : - INativeDialogService::CustomColorOpened; - - auto service = GetCurrentController()->DialogService(); - if (!service->ShowColorDialog(GetHostWindow()->GetNativeWindow(), selectedColor, showSelection, options, &colors[0])) - { - return false; - } - - CopyFrom(customColors, colors); - SelectedColorChanged.Execute(GuiEventArgs()); - return true; - } - -/*********************************************************************** -GuiFontDialog -***********************************************************************/ - - GuiFontDialog::GuiFontDialog() - { - } - - GuiFontDialog::~GuiFontDialog() - { - } - - const FontProperties& GuiFontDialog::GetSelectedFont() - { - return selectedFont; - } - - void GuiFontDialog::SetSelectedFont(const FontProperties& value) - { - if (selectedFont != value) - { - selectedFont = value; - SelectedFontChanged.Execute(GuiEventArgs()); - } - } - - Color GuiFontDialog::GetSelectedColor() - { - return selectedColor; - } - - void GuiFontDialog::SetSelectedColor(Color value) - { - if (selectedColor != value) - { - selectedColor = value; - SelectedColorChanged.Execute(GuiEventArgs()); - } - } - - bool GuiFontDialog::GetShowSelection() - { - return showSelection; - } - - void GuiFontDialog::SetShowSelection(bool value) - { - showSelection = value; - } - - bool GuiFontDialog::GetShowEffect() - { - return showEffect; - } - - void GuiFontDialog::SetShowEffect(bool value) - { - showEffect = value; - } - - bool GuiFontDialog::GetForceFontExist() - { - return forceFontExist; - } - - void GuiFontDialog::SetForceFontExist(bool value) - { - forceFontExist = value; - } - - bool GuiFontDialog::ShowDialog() - { - auto service = GetCurrentController()->DialogService(); - if (!service->ShowFontDialog(GetHostWindow()->GetNativeWindow(), selectedFont, selectedColor, showSelection, showEffect, forceFontExist)) - { - return false; - } - - SelectedColorChanged.Execute(GuiEventArgs()); - SelectedFontChanged.Execute(GuiEventArgs()); - return true; - } - -/*********************************************************************** -GuiFileDialogBase -***********************************************************************/ - - GuiFileDialogBase::GuiFileDialogBase() - { - } - - GuiFileDialogBase::~GuiFileDialogBase() - { - } - - const WString& GuiFileDialogBase::GetFilter() - { - return filter; - } - - void GuiFileDialogBase::SetFilter(const WString& value) - { - filter = value; - } - - vint GuiFileDialogBase::GetFilterIndex() - { - return filterIndex; - } - - void GuiFileDialogBase::SetFilterIndex(vint value) - { - if (filterIndex != value) - { - filterIndex = value; - FilterIndexChanged.Execute(GuiEventArgs()); - } - } - - bool GuiFileDialogBase::GetEnabledPreview() - { - return enabledPreview; - } - - void GuiFileDialogBase::SetEnabledPreview(bool value) - { - enabledPreview = value; - } - - WString GuiFileDialogBase::GetTitle() - { - return title; - } - - void GuiFileDialogBase::SetTitle(const WString& value) - { - title = value; - } - - WString GuiFileDialogBase::GetFileName() - { - return fileName; - } - - void GuiFileDialogBase::SetFileName(const WString& value) - { - if (fileName != value) - { - FileNameChanged.Execute(GuiEventArgs()); - } - } - - WString GuiFileDialogBase::GetDirectory() - { - return directory; - } - - void GuiFileDialogBase::SetDirectory(const WString& value) - { - directory = value; - } - - WString GuiFileDialogBase::GetDefaultExtension() - { - return defaultExtension; - } - - void GuiFileDialogBase::SetDefaultExtension(const WString& value) - { - defaultExtension = value; - } - - INativeDialogService::FileDialogOptions GuiFileDialogBase::GetOptions() - { - return options; - } - - void GuiFileDialogBase::SetOptions(INativeDialogService::FileDialogOptions value) - { - options = value; - } - -/*********************************************************************** -GuiOpenFileDialog -***********************************************************************/ - - GuiOpenFileDialog::GuiOpenFileDialog() - { - } - - GuiOpenFileDialog::~GuiOpenFileDialog() - { - } - - collections::List& GuiOpenFileDialog::GetFileNames() - { - return fileNames; - } - - bool GuiOpenFileDialog::ShowDialog() - { - fileNames.Clear(); - auto service = GetCurrentController()->DialogService(); - if (!service->ShowFileDialog( - GetHostWindow()->GetNativeWindow(), - fileNames, - filterIndex, - (enabledPreview ? INativeDialogService::FileDialogOpenPreview : INativeDialogService::FileDialogOpen), - title, - fileName, - directory, - defaultExtension, - filter, - options)) - { - return false; - } - - if (fileNames.Count() > 0) - { - fileName = fileNames[0]; - FileNameChanged.Execute(GuiEventArgs()); - FilterIndexChanged.Execute(GuiEventArgs()); - } - return true; - } - -/*********************************************************************** -GuiSaveFileDialog -***********************************************************************/ - - GuiSaveFileDialog::GuiSaveFileDialog() - { - } - - GuiSaveFileDialog::~GuiSaveFileDialog() - { - } - - bool GuiSaveFileDialog::ShowDialog() - { - List fileNames; - auto service = GetCurrentController()->DialogService(); - if (!service->ShowFileDialog( - GetHostWindow()->GetNativeWindow(), - fileNames, - filterIndex, - (enabledPreview ? INativeDialogService::FileDialogSavePreview : INativeDialogService::FileDialogSave), - title, - fileName, - directory, - defaultExtension, - filter, - options)) - { - return false; - } - - if (fileNames.Count() > 0) - { - fileName = fileNames[0]; - FileNameChanged.Execute(GuiEventArgs()); - FilterIndexChanged.Execute(GuiEventArgs()); - } - return true; - } - } - } -} - /*********************************************************************** .\CONTROLS\LISTCONTROLPACKAGE\GUILISTCONTROLS.CPP ***********************************************************************/ @@ -10110,7 +12007,11 @@ GuiListControl void GuiListControl::AfterControlTemplateInstalled_(bool initialize) { - callback->ClearCache(); + if (itemArranger) + { + itemArranger->ReloadVisibleStyles(); + CalculateView(); + } } void GuiListControl::OnItemModified(vint start, vint count, vint newCount) @@ -10193,6 +12094,12 @@ GuiListControl CalculateView(); } + void GuiListControl::OnClientBoundsChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + auto args = GetNotifyEventArguments(); + AdoptedSizeInvalidated.Execute(args); + } + void GuiListControl::OnVisuallyEnabledChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { FOREACH(ItemStyle*, style, visibleStyles.Keys()) @@ -10320,10 +12227,12 @@ GuiListControl { FontChanged.AttachMethod(this, &GuiListControl::OnFontChanged); VisuallyEnabledChanged.AttachMethod(this, &GuiListControl::OnVisuallyEnabledChanged); + containerComposition->BoundsChanged.AttachMethod(this, &GuiListControl::OnClientBoundsChanged); ItemTemplateChanged.SetAssociatedComposition(boundsComposition); ArrangerChanged.SetAssociatedComposition(boundsComposition); AxisChanged.SetAssociatedComposition(boundsComposition); + AdoptedSizeInvalidated.SetAssociatedComposition(boundsComposition); ItemLeftButtonDown.SetAssociatedComposition(boundsComposition); ItemLeftButtonUp.SetAssociatedComposition(boundsComposition); @@ -10837,6 +12746,3164 @@ ItemProviderBase } } +/*********************************************************************** +.\CONTROLS\TEMPLATES\GUICONTROLTEMPLATES.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace controls + { + using namespace reflection::description; + using namespace compositions; + +/*********************************************************************** +GuiComponent +***********************************************************************/ + + GuiComponent::GuiComponent() + { + } + + GuiComponent::~GuiComponent() + { + } + + void GuiComponent::Attach(GuiInstanceRootObject* rootObject) + { + } + + void GuiComponent::Detach(GuiInstanceRootObject* rootObject) + { + } + +/*********************************************************************** +GuiInstanceRootObject +***********************************************************************/ + + GuiInstanceRootObject::GuiInstanceRootObject() + { + } + + GuiInstanceRootObject::~GuiInstanceRootObject() + { + } + + void GuiInstanceRootObject::FinalizeInstance() + { + if (!finalized) + { + finalized = true; + + FOREACH(Ptr, subscription, subscriptions) + { + subscription->Close(); + } + FOREACH(GuiComponent*, component, components) + { + component->Detach(this); + } + + subscriptions.Clear(); + for (vint i = 0; i resolver) + { + resourceResolver = resolver; + } + + Ptr GuiInstanceRootObject::ResolveResource(const WString& protocol, const WString& path, bool ensureExist) + { + Ptr object; + if (resourceResolver) + { + object = resourceResolver->ResolveResource(protocol, path); + } + if (ensureExist && !object) + { + throw ArgumentException(L"Resource \"" + protocol + L"://" + path + L"\" does not exist."); + } + return object; + } + + Ptr GuiInstanceRootObject::AddSubscription(Ptr subscription) + { + CHECK_ERROR(finalized == false, L"GuiInstanceRootObject::AddSubscription(Ptr)#Cannot add subscription after finalizing."); + if (subscriptions.Contains(subscription.Obj())) + { + return nullptr; + } + else + { + subscriptions.Add(subscription); + subscription->Open(); + subscription->Update(); + return subscription; + } + } + + void GuiInstanceRootObject::UpdateSubscriptions() + { + FOREACH(Ptr, subscription, subscriptions) + { + subscription->Update(); + } + } + + bool GuiInstanceRootObject::AddComponent(GuiComponent* component) + { + CHECK_ERROR(finalized == false, L"GuiInstanceRootObject::AddComponent(GuiComponent*>)#Cannot add component after finalizing."); + if(components.Contains(component)) + { + return false; + } + else + { + components.Add(component); + component->Attach(this); + return true; + } + } + + bool GuiInstanceRootObject::AddControlHostComponent(GuiControlHost* controlHost) + { + return AddComponent(new GuiObjectComponent(controlHost)); + } + } + namespace templates + { + using namespace collections; + using namespace controls; + using namespace compositions; + using namespace elements; + +/*********************************************************************** +GuiTemplate +***********************************************************************/ + + GuiTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiTemplate::GuiTemplate() + :VisuallyEnabled_(true) + { + GuiTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiTemplate::~GuiTemplate() + { + FinalizeInstanceRecursively(this); + } + +/*********************************************************************** +GuiControlTemplate +***********************************************************************/ + + GuiControlTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiControlTemplate::GuiControlTemplate() + :ContainerComposition_(this) + , FocusableComposition_(0) + { + GuiControlTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiControlTemplate::~GuiControlTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiLabelTemplate +***********************************************************************/ + + GuiLabelTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiLabelTemplate::GuiLabelTemplate() + { + GuiLabelTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiLabelTemplate::~GuiLabelTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiSinglelineTextBoxTemplate +***********************************************************************/ + + GuiSinglelineTextBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiSinglelineTextBoxTemplate::GuiSinglelineTextBoxTemplate() + { + GuiSinglelineTextBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiSinglelineTextBoxTemplate::~GuiSinglelineTextBoxTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiDocumentLabelTemplate +***********************************************************************/ + + GuiDocumentLabelTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiDocumentLabelTemplate::GuiDocumentLabelTemplate() + { + GuiDocumentLabelTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiDocumentLabelTemplate::~GuiDocumentLabelTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiMenuTemplate +***********************************************************************/ + + GuiMenuTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiMenuTemplate::GuiMenuTemplate() + { + GuiMenuTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiMenuTemplate::~GuiMenuTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiWindowTemplate +***********************************************************************/ + + GuiWindowTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiWindowTemplate::GuiWindowTemplate() + :MaximizedBoxOption_(BoolOption::Customizable) + , MinimizedBoxOption_(BoolOption::Customizable) + , BorderOption_(BoolOption::Customizable) + , SizeBoxOption_(BoolOption::Customizable) + , IconVisibleOption_(BoolOption::Customizable) + , TitleBarOption_(BoolOption::Customizable) + , MaximizedBox_(true) + , MinimizedBox_(true) + , Border_(true) + , SizeBox_(true) + , IconVisible_(true) + , TitleBar_(true) + , CustomizedBorder_(false) + , Maximized_(false) + , CustomFrameEnabled_(true) + { + GuiWindowTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiWindowTemplate::~GuiWindowTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiButtonTemplate +***********************************************************************/ + + GuiButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiButtonTemplate::GuiButtonTemplate() + :State_(ButtonState::Normal) + { + GuiButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiButtonTemplate::~GuiButtonTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiSelectableButtonTemplate +***********************************************************************/ + + GuiSelectableButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiSelectableButtonTemplate::GuiSelectableButtonTemplate() + :Selected_(false) + { + GuiSelectableButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiSelectableButtonTemplate::~GuiSelectableButtonTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiToolstripButtonTemplate +***********************************************************************/ + + GuiToolstripButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiToolstripButtonTemplate::GuiToolstripButtonTemplate() + :SubMenuExisting_(false) + , SubMenuOpening_(false) + , SubMenuHost_(0) + { + GuiToolstripButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiToolstripButtonTemplate::~GuiToolstripButtonTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiListViewColumnHeaderTemplate +***********************************************************************/ + + GuiListViewColumnHeaderTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiListViewColumnHeaderTemplate::GuiListViewColumnHeaderTemplate() + :SortingState_(ColumnSortingState::NotSorted) + { + GuiListViewColumnHeaderTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiListViewColumnHeaderTemplate::~GuiListViewColumnHeaderTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiComboBoxTemplate +***********************************************************************/ + + GuiComboBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiComboBoxTemplate::GuiComboBoxTemplate() + :Commands_(nullptr) + , TextVisible_(true) + { + GuiComboBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiComboBoxTemplate::~GuiComboBoxTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiScrollTemplate +***********************************************************************/ + + GuiScrollTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiScrollTemplate::GuiScrollTemplate() + :Commands_(nullptr) + , TotalSize_(100) + , PageSize_(10) + , Position_(0) + { + GuiScrollTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiScrollTemplate::~GuiScrollTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiScrollViewTemplate +***********************************************************************/ + + GuiScrollViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiScrollViewTemplate::GuiScrollViewTemplate() + { + GuiScrollViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiScrollViewTemplate::~GuiScrollViewTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiMultilineTextBoxTemplate +***********************************************************************/ + + GuiMultilineTextBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiMultilineTextBoxTemplate::GuiMultilineTextBoxTemplate() + :Commands_(nullptr) + { + GuiMultilineTextBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiMultilineTextBoxTemplate::~GuiMultilineTextBoxTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiListControlTemplate +***********************************************************************/ + + GuiListControlTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiListControlTemplate::GuiListControlTemplate() + { + GuiListControlTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiListControlTemplate::~GuiListControlTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiTextListTemplate +***********************************************************************/ + + GuiTextListTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiTextListTemplate::GuiTextListTemplate() + { + GuiTextListTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiTextListTemplate::~GuiTextListTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiDocumentViewerTemplate +***********************************************************************/ + + GuiDocumentViewerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiDocumentViewerTemplate::GuiDocumentViewerTemplate() + { + GuiDocumentViewerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiDocumentViewerTemplate::~GuiDocumentViewerTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiListViewTemplate +***********************************************************************/ + + GuiListViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiListViewTemplate::GuiListViewTemplate() + { + GuiListViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiListViewTemplate::~GuiListViewTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiTreeViewTemplate +***********************************************************************/ + + GuiTreeViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiTreeViewTemplate::GuiTreeViewTemplate() + { + GuiTreeViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiTreeViewTemplate::~GuiTreeViewTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiTabTemplate +***********************************************************************/ + + GuiTabTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiTabTemplate::GuiTabTemplate() + :Commands_(nullptr) + , SelectedTabPage_(nullptr) + { + GuiTabTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiTabTemplate::~GuiTabTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiDatePickerTemplate +***********************************************************************/ + + GuiDatePickerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiDatePickerTemplate::GuiDatePickerTemplate() + :Commands_(nullptr) + { + GuiDatePickerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiDatePickerTemplate::~GuiDatePickerTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiDateComboBoxTemplate +***********************************************************************/ + + GuiDateComboBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiDateComboBoxTemplate::GuiDateComboBoxTemplate() + { + GuiDateComboBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiDateComboBoxTemplate::~GuiDateComboBoxTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiListItemTemplate +***********************************************************************/ + + void GuiListItemTemplate::OnInitialize() + { + } + + GuiListItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiListItemTemplate::GuiListItemTemplate() + :Selected_(false) + , Index_(0) + { + GuiListItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiListItemTemplate::~GuiListItemTemplate() + { + FinalizeAggregation(); + } + + void GuiListItemTemplate::BeginEditListItem() + { + listControl->GetItemProvider()->PushEditing(); + } + + void GuiListItemTemplate::EndEditListItem() + { + CHECK_ERROR(listControl->GetItemProvider()->PopEditing(), L"GuiListItemTemplate::EndEditListItem()#BeginEditListItem and EndEditListItem calls are not paired."); + } + + void GuiListItemTemplate::Initialize(controls::GuiListControl* _listControl) + { + CHECK_ERROR(listControl == nullptr, L"GuiListItemTemplate::Initialize(GuiListControl*)#This function can only be called once."); + listControl = _listControl; + OnInitialize(); + } + +/*********************************************************************** +GuiTextListItemTemplate +***********************************************************************/ + + GuiTextListItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiTextListItemTemplate::GuiTextListItemTemplate() + { + GuiTextListItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiTextListItemTemplate::~GuiTextListItemTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiTreeItemTemplate +***********************************************************************/ + + GuiTreeItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiTreeItemTemplate::GuiTreeItemTemplate() + :Expanding_(false) + , Expandable_(false) + , Level_(0) + { + GuiTreeItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiTreeItemTemplate::~GuiTreeItemTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiGridCellTemplate +***********************************************************************/ + + GuiGridCellTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiGridCellTemplate::GuiGridCellTemplate() + { + GuiGridCellTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiGridCellTemplate::~GuiGridCellTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiGridVisualizerTemplate +***********************************************************************/ + + GuiGridVisualizerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiGridVisualizerTemplate::GuiGridVisualizerTemplate() + { + GuiGridVisualizerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiGridVisualizerTemplate::~GuiGridVisualizerTemplate() + { + FinalizeAggregation(); + } + +/*********************************************************************** +GuiGridEditorTemplate +***********************************************************************/ + + GuiGridEditorTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + + GuiGridEditorTemplate::GuiGridEditorTemplate() + :CellValueSaved_(true) + , FocusControl_(nullptr) + { + GuiGridEditorTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) + } + + GuiGridEditorTemplate::~GuiGridEditorTemplate() + { + FinalizeAggregation(); + } + } + } +} + +/*********************************************************************** +.\CONTROLS\LISTCONTROLPACKAGE\GUILISTCONTROLITEMARRANGERS.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace controls + { + using namespace collections; + using namespace elements; + using namespace compositions; + + namespace list + { + +/*********************************************************************** +RangedItemArrangerBase +***********************************************************************/ + + void RangedItemArrangerBase::InvalidateAdoptedSize() + { + if (listControl) + { + listControl->AdoptedSizeInvalidated.Execute(listControl->GetNotifyEventArguments()); + } + } + + vint RangedItemArrangerBase::CalculateAdoptedSize(vint expectedSize, vint count, vint itemSize) + { + vint visibleCount = expectedSize / itemSize; + if (count < visibleCount) + { + visibleCount = count; + } + else if (count > visibleCount) + { + vint deltaA = expectedSize - count * itemSize; + vint deltaB = itemSize - deltaA; + if (deltaB < deltaA) + { + visibleCount++; + } + } + return visibleCount * itemSize; + } + + RangedItemArrangerBase::ItemStyleRecord RangedItemArrangerBase::CreateStyle(vint index) + { + GuiSelectableButton* backgroundButton = nullptr; + if (listControl->GetDisplayItemBackground()) + { + backgroundButton = new GuiSelectableButton(theme::ThemeName::ListItemBackground); + if (auto style = listControl->GetControlTemplateObject()->GetBackgroundTemplate()) + { + backgroundButton->SetControlTemplate(style); + } + backgroundButton->SetAutoSelection(false); + } + + auto itemStyle = callback->RequestItem(index, backgroundButton->GetBoundsComposition()); + if (backgroundButton) + { + itemStyle->SetAlignmentToParent(Margin(0, 0, 0, 0)); + itemStyle->SelectedChanged.AttachLambda([=](GuiGraphicsComposition* sender, GuiEventArgs& arguments) + { + backgroundButton->SetSelected(itemStyle->GetSelected()); + }); + backgroundButton->GetContainerComposition()->AddChild(itemStyle); + } + return { itemStyle, backgroundButton }; + } + + void RangedItemArrangerBase::DeleteStyle(ItemStyleRecord style) + { + callback->ReleaseItem(style.key); + if (style.value) + { + SafeDeleteControl(style.value); + } + } + + compositions::GuiBoundsComposition* RangedItemArrangerBase::GetStyleBounds(ItemStyleRecord style) + { + return style.value ? style.value->GetBoundsComposition() : style.key; + } + + void RangedItemArrangerBase::ClearStyles() + { + startIndex = 0; + if (callback) + { + for (vint i = 0; i < visibleStyles.Count(); i++) + { + DeleteStyle(visibleStyles[i]); + } + } + visibleStyles.Clear(); + viewBounds = Rect(0, 0, 0, 0); + InvalidateItemSizeCache(); + InvalidateAdoptedSize(); + } + + void RangedItemArrangerBase::OnViewChangedInternal(Rect oldBounds, Rect newBounds) + { + vint endIndex = startIndex + visibleStyles.Count() - 1; + vint newStartIndex = 0; + vint itemCount = itemProvider->Count(); + BeginPlaceItem(true, newBounds, newStartIndex); + if (newStartIndex < 0) newStartIndex = 0; + + StyleList newVisibleStyles; + for (vint i = newStartIndex; i < itemCount; i++) + { + auto style + = startIndex <= i && i <= endIndex + ? visibleStyles[i - startIndex] + : CreateStyle(i) + ; + newVisibleStyles.Add(style); + + Rect bounds; + Margin alignmentToParent; + PlaceItem(true, i, style, newBounds, bounds, alignmentToParent); + if (IsItemOutOfViewBounds(i, style, bounds, newBounds)) + { + break; + } + + bounds.x1 -= newBounds.x1; + bounds.x2 -= newBounds.x1; + bounds.y1 -= newBounds.y1; + bounds.y2 -= newBounds.y1; + } + + vint newEndIndex = newStartIndex + newVisibleStyles.Count() - 1; + for (vint i = 0; i < visibleStyles.Count(); i++) + { + vint index = startIndex + i; + if (index < newStartIndex || index > newEndIndex) + { + DeleteStyle(visibleStyles[i]); + } + } + CopyFrom(visibleStyles, newVisibleStyles); + + if (EndPlaceItem(true, newBounds, newStartIndex)) + { + callback->OnTotalSizeChanged(); + InvalidateAdoptedSize(); + } + startIndex = newStartIndex; + } + + void RangedItemArrangerBase::RearrangeItemBounds() + { + vint newStartIndex = startIndex; + BeginPlaceItem(false, viewBounds, newStartIndex); + for (vint i = 0; i < visibleStyles.Count(); i++) + { + auto style = visibleStyles[i]; + Rect bounds; + Margin alignmentToParent(-1, -1, -1, -1); + PlaceItem(false, startIndex + i, style, viewBounds, bounds, alignmentToParent); + + bounds.x1 -= viewBounds.x1; + bounds.x2 -= viewBounds.x1; + bounds.y1 -= viewBounds.y1; + bounds.y2 -= viewBounds.y1; + + callback->SetStyleAlignmentToParent(GetStyleBounds(style), alignmentToParent); + callback->SetStyleBounds(GetStyleBounds(style), bounds); + } + EndPlaceItem(false, viewBounds, startIndex); + } + + RangedItemArrangerBase::RangedItemArrangerBase() + { + } + + RangedItemArrangerBase::~RangedItemArrangerBase() + { + } + + void RangedItemArrangerBase::OnAttached(GuiListControl::IItemProvider* provider) + { + itemProvider = provider; + if (provider) + { + OnItemModified(0, 0, provider->Count()); + } + } + + void RangedItemArrangerBase::OnItemModified(vint start, vint count, vint newCount) + { + if (callback && !itemProvider->IsEditing()) + { + suppressOnViewChanged = true; + { + vint visibleCount = visibleStyles.Count(); + vint itemCount = itemProvider->Count(); + SortedList reusedStyles; + for (vint i = 0; i < visibleCount; i++) + { + vint index = startIndex + i; + if (index >= itemCount) + { + break; + } + + vint oldIndex = -1; + if (index < start) + { + oldIndex = index; + } + else if (index >= start + newCount) + { + oldIndex = index - newCount + count; + } + + if (oldIndex != -1) + { + if (oldIndex >= startIndex && oldIndex < startIndex + visibleCount) + { + auto style = visibleStyles[oldIndex - startIndex]; + reusedStyles.Add(style); + visibleStyles.Add(style); + } + else + { + oldIndex = -1; + } + } + if (oldIndex == -1) + { + visibleStyles.Add(CreateStyle(index)); + } + } + + for (vint i = 0; i < visibleCount; i++) + { + auto style = visibleStyles[i]; + if (!reusedStyles.Contains(style)) + { + DeleteStyle(style); + } + } + + visibleStyles.RemoveRange(0, visibleCount); + for (vint i = 0; i < visibleStyles.Count(); i++) + { + visibleStyles[i].key->SetIndex(startIndex + i); + } + } + suppressOnViewChanged = false; + + callback->OnTotalSizeChanged(); + callback->SetViewLocation(viewBounds.LeftTop()); + InvalidateAdoptedSize(); + } + } + + void RangedItemArrangerBase::AttachListControl(GuiListControl* value) + { + listControl = value; + InvalidateAdoptedSize(); + } + + void RangedItemArrangerBase::DetachListControl() + { + listControl = 0; + } + + GuiListControl::IItemArrangerCallback* RangedItemArrangerBase::GetCallback() + { + return callback; + } + + void RangedItemArrangerBase::SetCallback(GuiListControl::IItemArrangerCallback* value) + { + if (callback != value) + { + ClearStyles(); + callback = value; + } + } + + Size RangedItemArrangerBase::GetTotalSize() + { + if (callback) + { + return OnCalculateTotalSize(); + } + else + { + return Size(0, 0); + } + } + + GuiListControl::ItemStyle* RangedItemArrangerBase::GetVisibleStyle(vint itemIndex) + { + if (startIndex <= itemIndex && itemIndex < startIndex + visibleStyles.Count()) + { + return visibleStyles[itemIndex - startIndex].key; + } + else + { + return 0; + } + } + + vint RangedItemArrangerBase::GetVisibleIndex(GuiListControl::ItemStyle* style) + { + for (vint i = 0; i < visibleStyles.Count(); i++) + { + if (visibleStyles[i].key == style) + { + return i + startIndex; + } + } + return -1; + } + + void RangedItemArrangerBase::ReloadVisibleStyles() + { + ClearStyles(); + } + + void RangedItemArrangerBase::OnViewChanged(Rect bounds) + { + if (!suppressOnViewChanged) + { + suppressOnViewChanged = true; + Rect oldBounds = viewBounds; + viewBounds = bounds; + if (callback) + { + OnViewChangedInternal(oldBounds, viewBounds); + RearrangeItemBounds(); + } + suppressOnViewChanged = false; + } + } + +/*********************************************************************** +FixedHeightItemArranger +***********************************************************************/ + + vint FixedHeightItemArranger::GetWidth() + { + return -1; + } + + vint FixedHeightItemArranger::GetYOffset() + { + return 0; + } + + void FixedHeightItemArranger::BeginPlaceItem(bool forMoving, Rect newBounds, vint& newStartIndex) + { + pi_width = GetWidth(); + if (forMoving) + { + pim_rowHeight = rowHeight; + newStartIndex = (newBounds.Top() - GetYOffset()) / rowHeight; + } + } + + void FixedHeightItemArranger::PlaceItem(bool forMoving, vint index, ItemStyleRecord style, Rect viewBounds, Rect& bounds, Margin& alignmentToParent) + { + vint top = GetYOffset() + index * rowHeight; + if (pi_width == -1) + { + alignmentToParent = Margin(0, -1, 0, -1); + bounds = Rect(Point(0, top), Size(0, rowHeight)); + } + else + { + alignmentToParent = Margin(-1, -1, -1, -1); + bounds = Rect(Point(0, top), Size(pi_width, rowHeight)); + } + if (forMoving) + { + vint styleHeight = callback->GetStylePreferredSize(GetStyleBounds(style)).y; + if (pim_rowHeight < styleHeight) + { + pim_rowHeight = styleHeight; + } + } + } + + bool FixedHeightItemArranger::IsItemOutOfViewBounds(vint index, ItemStyleRecord style, Rect bounds, Rect viewBounds) + { + return bounds.Top() >= viewBounds.Bottom(); + } + + bool FixedHeightItemArranger::EndPlaceItem(bool forMoving, Rect newBounds, vint newStartIndex) + { + if (forMoving) + { + if (pim_rowHeight != rowHeight) + { + vint offset = (pim_rowHeight - rowHeight) * newStartIndex; + rowHeight = pim_rowHeight; + callback->SetViewLocation(Point(0, newBounds.Top() + offset)); + return true; + } + } + return false; + } + + void FixedHeightItemArranger::InvalidateItemSizeCache() + { + rowHeight = 1; + } + + Size FixedHeightItemArranger::OnCalculateTotalSize() + { + vint width = GetWidth(); + if (width < 0) width = 0; + return Size(width, rowHeight * itemProvider->Count() + GetYOffset()); + } + + FixedHeightItemArranger::FixedHeightItemArranger() + :rowHeight(1) + { + } + + FixedHeightItemArranger::~FixedHeightItemArranger() + { + } + + vint FixedHeightItemArranger::FindItem(vint itemIndex, compositions::KeyDirection key) + { + vint count = itemProvider->Count(); + if (count == 0) return -1; + vint groupCount = viewBounds.Height() / rowHeight; + if (groupCount == 0) groupCount = 1; + switch (key) + { + case KeyDirection::Up: + itemIndex--; + break; + case KeyDirection::Down: + itemIndex++; + break; + case KeyDirection::Home: + itemIndex = 0; + break; + case KeyDirection::End: + itemIndex = count; + break; + case KeyDirection::PageUp: + itemIndex -= groupCount; + break; + case KeyDirection::PageDown: + itemIndex += groupCount; + break; + default: + return -1; + } + + if (itemIndex < 0) return 0; + else if (itemIndex >= count) return count - 1; + else return itemIndex; + } + + bool FixedHeightItemArranger::EnsureItemVisible(vint itemIndex) + { + if (callback) + { + if (itemIndex < 0 || itemIndex >= itemProvider->Count()) + { + return false; + } + while (true) + { + vint yOffset = GetYOffset(); + vint top = itemIndex*rowHeight; + vint bottom = top + rowHeight + yOffset; + + if (viewBounds.Height() < rowHeight) + { + if (viewBounds.Top() < bottom && top < viewBounds.Bottom()) + { + break; + } + } + + Point location = viewBounds.LeftTop(); + if (top < viewBounds.Top()) + { + location.y = top; + } + else if (viewBounds.Bottom() < bottom) + { + location.y = bottom - viewBounds.Height(); + } + else + { + break; + } + callback->SetViewLocation(location); + } + return true; + } + return false; + } + + Size FixedHeightItemArranger::GetAdoptedSize(Size expectedSize) + { + if (itemProvider) + { + vint yOffset = GetYOffset(); + vint y = expectedSize.y - yOffset; + vint itemCount = itemProvider->Count(); + return Size(expectedSize.x, yOffset + CalculateAdoptedSize(y, itemCount, rowHeight)); + } + return expectedSize; + } + +/*********************************************************************** +FixedSizeMultiColumnItemArranger +***********************************************************************/ + + void FixedSizeMultiColumnItemArranger::BeginPlaceItem(bool forMoving, Rect newBounds, vint& newStartIndex) + { + if (forMoving) + { + pim_itemSize = itemSize; + vint rows = newBounds.Top() / itemSize.y; + if (rows < 0) rows = 0; + vint cols = newBounds.Width() / itemSize.x; + if (cols < 1) cols = 1; + newStartIndex = rows * cols; + } + } + + void FixedSizeMultiColumnItemArranger::PlaceItem(bool forMoving, vint index, ItemStyleRecord style, Rect viewBounds, Rect& bounds, Margin& alignmentToParent) + { + vint rowItems = viewBounds.Width() / itemSize.x; + if (rowItems < 1) rowItems = 1; + + vint row = index / rowItems; + vint col = index % rowItems; + bounds = Rect(Point(col * itemSize.x, row * itemSize.y), itemSize); + if (forMoving) + { + Size styleSize = callback->GetStylePreferredSize(GetStyleBounds(style)); + if (pim_itemSize.x < styleSize.x) pim_itemSize.x = styleSize.x; + if (pim_itemSize.y < styleSize.y) pim_itemSize.y = styleSize.y; + } + } + + bool FixedSizeMultiColumnItemArranger::IsItemOutOfViewBounds(vint index, ItemStyleRecord style, Rect bounds, Rect viewBounds) + { + return bounds.Top() >= viewBounds.Bottom(); + } + + bool FixedSizeMultiColumnItemArranger::EndPlaceItem(bool forMoving, Rect newBounds, vint newStartIndex) + { + if (forMoving) + { + if (pim_itemSize != itemSize) + { + itemSize = pim_itemSize; + return true; + } + } + return false; + } + + void FixedSizeMultiColumnItemArranger::CalculateRange(Size itemSize, Rect bounds, vint count, vint& start, vint& end) + { + vint startRow = bounds.Top() / itemSize.y; + if (startRow < 0) startRow = 0; + vint endRow = (bounds.Bottom() - 1) / itemSize.y; + vint cols = bounds.Width() / itemSize.x; + if (cols < 1) cols = 1; + + start = startRow*cols; + end = (endRow + 1)*cols - 1; + if (end >= count) end = count - 1; + } + + void FixedSizeMultiColumnItemArranger::InvalidateItemSizeCache() + { + itemSize = Size(1, 1); + } + + Size FixedSizeMultiColumnItemArranger::OnCalculateTotalSize() + { + vint rowItems = viewBounds.Width() / itemSize.x; + if (rowItems < 1) rowItems = 1; + vint rows = itemProvider->Count() / rowItems; + if (itemProvider->Count() % rowItems) rows++; + + return Size(itemSize.x * rowItems, itemSize.y*rows); + } + + FixedSizeMultiColumnItemArranger::FixedSizeMultiColumnItemArranger() + :itemSize(1, 1) + { + } + + FixedSizeMultiColumnItemArranger::~FixedSizeMultiColumnItemArranger() + { + } + + vint FixedSizeMultiColumnItemArranger::FindItem(vint itemIndex, compositions::KeyDirection key) + { + vint count = itemProvider->Count(); + vint columnCount = viewBounds.Width() / itemSize.x; + if (columnCount == 0) columnCount = 1; + vint rowCount = viewBounds.Height() / itemSize.y; + if (rowCount == 0) rowCount = 1; + + switch (key) + { + case KeyDirection::Up: + itemIndex -= columnCount; + break; + case KeyDirection::Down: + itemIndex += columnCount; + break; + case KeyDirection::Left: + itemIndex--; + break; + case KeyDirection::Right: + itemIndex++; + break; + case KeyDirection::Home: + itemIndex = 0; + break; + case KeyDirection::End: + itemIndex = count; + break; + case KeyDirection::PageUp: + itemIndex -= columnCount*rowCount; + break; + case KeyDirection::PageDown: + itemIndex += columnCount*rowCount; + break; + case KeyDirection::PageLeft: + itemIndex -= itemIndex%columnCount; + break; + case KeyDirection::PageRight: + itemIndex += columnCount - itemIndex%columnCount - 1; + break; + default: + return -1; + } + + if (itemIndex < 0) return 0; + else if (itemIndex >= count) return count - 1; + else return itemIndex; + } + + bool FixedSizeMultiColumnItemArranger::EnsureItemVisible(vint itemIndex) + { + if (callback) + { + if (itemIndex < 0 || itemIndex >= itemProvider->Count()) + { + return false; + } + while (true) + { + vint rowHeight = itemSize.y; + vint columnCount = viewBounds.Width() / itemSize.x; + if (columnCount == 0) columnCount = 1; + vint rowIndex = itemIndex / columnCount; + + vint top = rowIndex*rowHeight; + vint bottom = top + rowHeight; + + if (viewBounds.Height() < rowHeight) + { + if (viewBounds.Top() < bottom && top < viewBounds.Bottom()) + { + break; + } + } + + Point location = viewBounds.LeftTop(); + if (top < viewBounds.Top()) + { + location.y = top; + } + else if (viewBounds.Bottom() < bottom) + { + location.y = bottom - viewBounds.Height(); + } + else + { + break; + } + callback->SetViewLocation(location); + } + return true; + } + return false; + } + + Size FixedSizeMultiColumnItemArranger::GetAdoptedSize(Size expectedSize) + { + if (itemProvider) + { + vint count = itemProvider->Count(); + vint columnCount = viewBounds.Width() / itemSize.x; + vint rowCount = viewBounds.Height() / itemSize.y; + return Size( + CalculateAdoptedSize(expectedSize.x, columnCount, itemSize.x), + CalculateAdoptedSize(expectedSize.y, rowCount, itemSize.y) + ); + } + return expectedSize; + } + +/*********************************************************************** +FixedHeightMultiColumnItemArranger +***********************************************************************/ + + void FixedHeightMultiColumnItemArranger::BeginPlaceItem(bool forMoving, Rect newBounds, vint& newStartIndex) + { + pi_currentWidth = 0; + pi_totalWidth = 0; + if (forMoving) + { + pim_itemHeight = itemHeight; + vint rows = newBounds.Height() / itemHeight; + if (rows < 1) rows = 1; + vint columns = newBounds.Left() / newBounds.Width(); + newStartIndex = rows * columns; + } + } + + void FixedHeightMultiColumnItemArranger::PlaceItem(bool forMoving, vint index, ItemStyleRecord style, Rect viewBounds, Rect& bounds, Margin& alignmentToParent) + { + vint rows = viewBounds.Height() / itemHeight; + if (rows < 1) rows = 1; + + vint row = index % rows; + if (row == 0) + { + pi_totalWidth += pi_currentWidth; + pi_currentWidth = 0; + } + + Size styleSize = callback->GetStylePreferredSize(GetStyleBounds(style)); + if (pi_currentWidth < styleSize.x) pi_currentWidth = styleSize.x; + bounds = Rect(Point(pi_totalWidth + viewBounds.Left(), itemHeight * row), Size(0, 0)); + if (forMoving) + { + if (pim_itemHeight < styleSize.y) pim_itemHeight = styleSize.y; + } + } + + bool FixedHeightMultiColumnItemArranger::IsItemOutOfViewBounds(vint index, ItemStyleRecord style, Rect bounds, Rect viewBounds) + { + return bounds.Left() >= viewBounds.Right(); + } + + bool FixedHeightMultiColumnItemArranger::EndPlaceItem(bool forMoving, Rect newBounds, vint newStartIndex) + { + if (forMoving) + { + if (pim_itemHeight != itemHeight) + { + itemHeight = pim_itemHeight; + return true; + } + } + return false; + } + + void FixedHeightMultiColumnItemArranger::CalculateRange(vint itemHeight, Rect bounds, vint& rows, vint& startColumn) + { + rows = bounds.Height() / itemHeight; + if (rows < 1) rows = 1; + startColumn = bounds.Left() / bounds.Width(); + } + + void FixedHeightMultiColumnItemArranger::InvalidateItemSizeCache() + { + itemHeight = 1; + } + + Size FixedHeightMultiColumnItemArranger::OnCalculateTotalSize() + { + vint rows = viewBounds.Height() / itemHeight; + if (rows < 1) rows = 1; + vint columns = itemProvider->Count() / rows; + if (itemProvider->Count() % rows) columns += 1; + return Size(viewBounds.Width() * columns, 0); + } + + FixedHeightMultiColumnItemArranger::FixedHeightMultiColumnItemArranger() + :itemHeight(1) + { + } + + FixedHeightMultiColumnItemArranger::~FixedHeightMultiColumnItemArranger() + { + } + + vint FixedHeightMultiColumnItemArranger::FindItem(vint itemIndex, compositions::KeyDirection key) + { + vint count = itemProvider->Count(); + vint groupCount = viewBounds.Height() / itemHeight; + if (groupCount == 0) groupCount = 1; + switch (key) + { + case KeyDirection::Up: + itemIndex--; + break; + case KeyDirection::Down: + itemIndex++; + break; + case KeyDirection::Left: + itemIndex -= groupCount; + break; + case KeyDirection::Right: + itemIndex += groupCount; + break; + case KeyDirection::Home: + itemIndex = 0; + break; + case KeyDirection::End: + itemIndex = count; + break; + case KeyDirection::PageUp: + itemIndex -= itemIndex%groupCount; + break; + case KeyDirection::PageDown: + itemIndex += groupCount - itemIndex%groupCount - 1; + break; + default: + return -1; + } + + if (itemIndex < 0) return 0; + else if (itemIndex >= count) return count - 1; + else return itemIndex; + } + + bool FixedHeightMultiColumnItemArranger::EnsureItemVisible(vint itemIndex) + { + if (callback) + { + if (itemIndex < 0 || itemIndex >= itemProvider->Count()) + { + return false; + } + while (true) + { + vint rowCount = viewBounds.Height() / itemHeight; + if (rowCount == 0) rowCount = 1; + vint columnIndex = itemIndex / rowCount; + vint minIndex = startIndex; + vint maxIndex = startIndex + visibleStyles.Count() - 1; + + Point location = viewBounds.LeftTop(); + if (minIndex <= itemIndex && itemIndex <= maxIndex) + { + Rect bounds = callback->GetStyleBounds(GetStyleBounds(visibleStyles[itemIndex - startIndex])); + if (0 < bounds.Bottom() && bounds.Top() < viewBounds.Width() && bounds.Width() > viewBounds.Width()) + { + break; + } + else if (bounds.Left() < 0) + { + location.x -= viewBounds.Width(); + } + else if (bounds.Right() > viewBounds.Width()) + { + location.x += viewBounds.Width(); + } + else + { + break; + } + } + else if (columnIndex < minIndex / rowCount) + { + location.x -= viewBounds.Width(); + } + else if (columnIndex >= maxIndex / rowCount) + { + location.x += viewBounds.Width(); + } + else + { + break; + } + callback->SetViewLocation(location); + } + return true; + } + return false; + } + + Size FixedHeightMultiColumnItemArranger::GetAdoptedSize(Size expectedSize) + { + if (itemProvider) + { + vint count = itemProvider->Count(); + return Size(expectedSize.x, CalculateAdoptedSize(expectedSize.y, count, itemHeight)); + } + return expectedSize; + } + } + } + } +} + +/*********************************************************************** +.\CONTROLS\LISTCONTROLPACKAGE\GUITEXTLISTCONTROLS.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace controls + { + using namespace collections; + using namespace elements; + using namespace compositions; + using namespace reflection::description; + + namespace list + { + const wchar_t* const ITextItemView::Identifier = L"vl::presentation::controls::list::ITextItemView"; + +/*********************************************************************** +DefaultTextListItemTemplate +***********************************************************************/ + + TemplateProperty DefaultTextListItemTemplate::CreateBulletStyle() + { + return {}; + } + + void DefaultTextListItemTemplate::OnInitialize() + { + SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + + textElement = GuiSolidLabelElement::Create(); + textElement->SetAlignments(Alignment::Left, Alignment::Center); + + GuiBoundsComposition* textComposition = new GuiBoundsComposition; + textComposition->SetOwnedElement(textElement); + textComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElement); + + if (auto bulletStyleController = CreateBulletStyle()) + { + bulletButton = new GuiSelectableButton(theme::ThemeName::Unknown); + bulletButton->SetControlTemplate(bulletStyleController); + bulletButton->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); + bulletButton->SelectedChanged.AttachMethod(this, &DefaultTextListItemTemplate::OnBulletSelectedChanged); + + GuiTableComposition* table = new GuiTableComposition; + AddChild(table); + table->SetAlignmentToParent(Margin(0, 0, 0, 0)); + table->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + table->SetRowsAndColumns(1, 2); + table->SetRowOption(0, GuiCellOption::PercentageOption(1.0)); + table->SetColumnOption(0, GuiCellOption::MinSizeOption()); + table->SetColumnOption(1, GuiCellOption::PercentageOption(1.0)); + { + GuiCellComposition* cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(0, 0, 1, 1); + cell->AddChild(bulletButton->GetBoundsComposition()); + } + { + GuiCellComposition* cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(0, 1, 1, 1); + cell->AddChild(textComposition); + textComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + } + } + else + { + AddChild(textComposition); + textComposition->SetAlignmentToParent(Margin(5, 0, 0, 0)); + } + + FontChanged.AttachMethod(this, &DefaultTextListItemTemplate::OnFontChanged); + TextChanged.AttachMethod(this, &DefaultTextListItemTemplate::OnTextChanged); + TextColorChanged.AttachMethod(this, &DefaultTextListItemTemplate::OnTextColorChanged); + CheckedChanged.AttachMethod(this, &DefaultTextListItemTemplate::OnCheckedChanged); + + FontChanged.Execute(compositions::GuiEventArgs(this)); + TextChanged.Execute(compositions::GuiEventArgs(this)); + TextColorChanged.Execute(compositions::GuiEventArgs(this)); + CheckedChanged.Execute(compositions::GuiEventArgs(this)); + } + + void DefaultTextListItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + textElement->SetFont(GetFont()); + } + + void DefaultTextListItemTemplate::OnTextChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + textElement->SetText(GetText()); + } + + void DefaultTextListItemTemplate::OnTextColorChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + textElement->SetColor(GetTextColor()); + } + + void DefaultTextListItemTemplate::OnCheckedChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if (bulletButton) + { + supressEdit = true; + bulletButton->SetSelected(GetChecked()); + supressEdit = false; + } + } + + void DefaultTextListItemTemplate::OnBulletSelectedChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if (!supressEdit) + { + if (auto textItemView = dynamic_cast(listControl->GetItemProvider()->RequestView(ITextItemView::Identifier))) + { + BeginEditListItem(); + textItemView->SetChecked(GetIndex(), bulletButton->GetSelected()); + EndEditListItem(); + } + } + } + + DefaultTextListItemTemplate::DefaultTextListItemTemplate() + { + } + + DefaultTextListItemTemplate::~DefaultTextListItemTemplate() + { + } + +/*********************************************************************** +DefaultCheckTextListItemTemplate +***********************************************************************/ + + TemplateProperty DefaultCheckTextListItemTemplate::CreateBulletStyle() + { + if (auto textList = dynamic_cast(listControl)) + { + auto style = textList->GetControlTemplateObject()->GetCheckBulletTemplate(); + if (style) return style; + } + return theme::GetCurrentTheme()->CreateStyle(theme::ThemeName::CheckTextListItem); + } + +/*********************************************************************** +DefaultRadioTextListItemTemplate +***********************************************************************/ + + TemplateProperty DefaultRadioTextListItemTemplate::CreateBulletStyle() + { + if (auto textList = dynamic_cast(listControl)) + { + auto style = textList->GetControlTemplateObject()->GetRadioBulletTemplate(); + if (style) return style; + } + return theme::GetCurrentTheme()->CreateStyle(theme::ThemeName::RadioTextListItem); + } + +/*********************************************************************** +TextItem +***********************************************************************/ + + TextItem::TextItem() + :owner(0) + , checked(false) + { + } + + TextItem::TextItem(const WString& _text, bool _checked) + :owner(0) + , text(_text) + , checked(_checked) + { + } + + TextItem::~TextItem() + { + } + + bool TextItem::operator==(const TextItem& value)const + { + return text==value.text; + } + + bool TextItem::operator!=(const TextItem& value)const + { + return text!=value.text; + } + + const WString& TextItem::GetText() + { + return text; + } + + void TextItem::SetText(const WString& value) + { + if (text != value) + { + text = value; + if (owner) + { + vint index = owner->IndexOf(this); + owner->InvokeOnItemModified(index, 1, 1); + } + } + } + + bool TextItem::GetChecked() + { + return checked; + } + + void TextItem::SetChecked(bool value) + { + if (checked != value) + { + checked = value; + if (owner) + { + vint index = owner->IndexOf(this); + owner->InvokeOnItemModified(index, 1, 1); + + GuiItemEventArgs arguments; + arguments.itemIndex = index; + owner->listControl->ItemChecked.Execute(arguments); + } + } + } + +/*********************************************************************** +TextItemProvider +***********************************************************************/ + + void TextItemProvider::AfterInsert(vint item, const Ptr& value) + { + ListProvider>::AfterInsert(item, value); + value->owner = this; + } + + void TextItemProvider::BeforeRemove(vint item, const Ptr& value) + { + value->owner = 0; + ListProvider>::BeforeRemove(item, value); + } + + WString TextItemProvider::GetTextValue(vint itemIndex) + { + return Get(itemIndex)->GetText(); + } + + description::Value TextItemProvider::GetBindingValue(vint itemIndex) + { + return Value::From(Get(itemIndex)); + } + + bool TextItemProvider::GetChecked(vint itemIndex) + { + return Get(itemIndex)->GetChecked(); + } + + void TextItemProvider::SetChecked(vint itemIndex, bool value) + { + return Get(itemIndex)->SetChecked(value); + } + + TextItemProvider::TextItemProvider() + :listControl(0) + { + } + + TextItemProvider::~TextItemProvider() + { + } + + IDescriptable* TextItemProvider::RequestView(const WString& identifier) + { + if (identifier == ITextItemView::Identifier) + { + return (ITextItemView*)this; + } + else + { + return nullptr; + } + } + } + +/*********************************************************************** +GuiTextList +***********************************************************************/ + + void GuiVirtualTextList::BeforeControlTemplateUninstalled_() + { + } + + void GuiVirtualTextList::AfterControlTemplateInstalled_(bool initialize) + { + } + + void GuiVirtualTextList::OnStyleInstalled(vint itemIndex, ItemStyle* style) + { + GuiSelectableListControl::OnStyleInstalled(itemIndex, style); + if (auto textItemStyle = dynamic_cast(style)) + { + textItemStyle->SetTextColor(GetControlTemplateObject()->GetTextColor()); + if (auto textItemView = dynamic_cast(itemProvider->RequestView(list::ITextItemView::Identifier))) + { + textItemStyle->SetChecked(textItemView->GetChecked(itemIndex)); + } + } + } + + void GuiVirtualTextList::OnItemTemplateChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + view = TextListView::Unknown; + } + + GuiVirtualTextList::GuiVirtualTextList(theme::ThemeName themeName, GuiListControl::IItemProvider* _itemProvider) + :GuiSelectableListControl(themeName, _itemProvider) + { + ItemTemplateChanged.AttachMethod(this, &GuiVirtualTextList::OnItemTemplateChanged); + ItemChecked.SetAssociatedComposition(boundsComposition); + + SetView(TextListView::Text); + } + + GuiVirtualTextList::~GuiVirtualTextList() + { + } + + TextListView GuiVirtualTextList::GetView() + { + return view; + } + + void GuiVirtualTextList::SetView(TextListView _view) + { + switch (_view) + { + case TextListView::Text: + SetStyleAndArranger( + [](const Value&) { return new list::DefaultTextListItemTemplate; }, + new list::FixedHeightItemArranger + ); + break; + case TextListView::Check: + SetStyleAndArranger( + [](const Value&) { return new list::DefaultCheckTextListItemTemplate; }, + new list::FixedHeightItemArranger + ); + break; + case TextListView::Radio: + SetStyleAndArranger( + [](const Value&) { return new list::DefaultRadioTextListItemTemplate; }, + new list::FixedHeightItemArranger + ); + break; + default:; + } + view = _view; + } + +/*********************************************************************** +GuiTextList +***********************************************************************/ + + GuiTextList::GuiTextList(theme::ThemeName themeName) + :GuiVirtualTextList(themeName, new list::TextItemProvider) + { + items=dynamic_cast(itemProvider.Obj()); + items->listControl=this; + } + + GuiTextList::~GuiTextList() + { + } + + list::TextItemProvider& GuiTextList::GetItems() + { + return *items; + } + + Ptr GuiTextList::GetSelectedItem() + { + vint index = GetSelectedItemIndex(); + if (index == -1) return 0; + return items->Get(index); + } + } + } +} + +/*********************************************************************** +.\CONTROLS\LISTCONTROLPACKAGE\GUITREEVIEWCONTROLS.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace controls + { + using namespace elements; + using namespace compositions; + using namespace reflection::description; + + namespace tree + { + const wchar_t* const INodeItemView::Identifier = L"vl::presentation::controls::tree::INodeItemView"; + +/*********************************************************************** +NodeItemProvider +***********************************************************************/ + + INodeProvider* NodeItemProvider::GetNodeByOffset(INodeProvider* provider, vint offset) + { + if(offset==0) return provider; + INodeProvider* result=0; + if(provider->GetExpanding() && offset>0) + { + offset-=1; + vint count=provider->GetChildCount(); + for(vint i=0;(!result && iGetChild(i); + vint visibleCount=child->CalculateTotalVisibleNodes(); + if(offsetGetExpanding()) + { + for(vint i=0;iGetChild(start+i); + offset+=child->CalculateTotalVisibleNodes(); + child->Release(); + } + } + offsetBeforeChildModifieds.Set(parentNode, offset); + } + + void NodeItemProvider::OnAfterItemModified(INodeProvider* parentNode, vint start, vint count, vint newCount) + { + vint offsetBeforeChildModified = 0; + { + vint index = offsetBeforeChildModifieds.Keys().IndexOf(parentNode); + if (index != -1) + { + offsetBeforeChildModified = offsetBeforeChildModifieds.Values().Get(index); + offsetBeforeChildModifieds.Remove(parentNode); + } + } + + vint base=CalculateNodeVisibilityIndexInternal(parentNode); + if(base!=-2 && parentNode->GetExpanding()) + { + vint offset=0; + vint firstChildStart=-1; + for(vint i=0;iGetChild(start+i); + if(i==0) + { + firstChildStart=CalculateNodeVisibilityIndexInternal(child); + } + offset+=child->CalculateTotalVisibleNodes(); + child->Release(); + } + + if(firstChildStart==-1) + { + vint childCount=parentNode->GetChildCount(); + if(childCount==0) + { + firstChildStart=base+1; + } + else if(startGetChild(start); + firstChildStart=CalculateNodeVisibilityIndexInternal(child); + child->Release(); + } + else + { + INodeProvider* child=parentNode->GetChild(start-1); + firstChildStart=CalculateNodeVisibilityIndexInternal(child); + firstChildStart+=child->CalculateTotalVisibleNodes(); + child->Release(); + } + } + InvokeOnItemModified(firstChildStart, offsetBeforeChildModified, offset); + } + } + + void NodeItemProvider::OnItemExpanded(INodeProvider* node) + { + vint base=CalculateNodeVisibilityIndexInternal(node); + if(base!=-2) + { + vint visibility=node->CalculateTotalVisibleNodes(); + InvokeOnItemModified(base+1, 0, visibility-1); + } + } + + void NodeItemProvider::OnItemCollapsed(INodeProvider* node) + { + vint base=CalculateNodeVisibilityIndexInternal(node); + if(base!=-2) + { + vint visibility=0; + vint count=node->GetChildCount(); + for(vint i=0;iGetChild(i); + visibility+=child->CalculateTotalVisibleNodes(); + child->Release(); + } + InvokeOnItemModified(base+1, visibility, 0); + } + } + + vint NodeItemProvider::CalculateNodeVisibilityIndexInternal(INodeProvider* node) + { + INodeProvider* parent=node->GetParent(); + if(parent==0) + { + return -1; + } + if(!parent->GetExpanding()) + { + return -2; + } + + vint index=CalculateNodeVisibilityIndexInternal(parent); + if(index==-2) + { + return -2; + } + + vint count=parent->GetChildCount(); + for(vint i=0;iGetChild(i); + bool findResult=child==node; + if(findResult) + { + index++; + } + else + { + index+=child->CalculateTotalVisibleNodes(); + } + child->Release(); + if(findResult) + { + return index; + } + } + return -1; + } + + vint NodeItemProvider::CalculateNodeVisibilityIndex(INodeProvider* node) + { + vint result=CalculateNodeVisibilityIndexInternal(node); + return result<0?-1:result; + } + + INodeProvider* NodeItemProvider::RequestNode(vint index) + { + if(root->CanGetNodeByVisibleIndex()) + { + return root->GetNodeByVisibleIndex(index+1); + } + else + { + return GetNodeByOffset(root->GetRootNode(), index+1); + } + } + + void NodeItemProvider::ReleaseNode(INodeProvider* node) + { + if(node) + { + node->Release(); + } + } + + NodeItemProvider::NodeItemProvider(Ptr _root) + :root(_root) + { + root->AttachCallback(this); + } + + NodeItemProvider::~NodeItemProvider() + { + root->DetachCallback(this); + } + + Ptr NodeItemProvider::GetRoot() + { + return root; + } + + vint NodeItemProvider::Count() + { + return root->GetRootNode()->CalculateTotalVisibleNodes()-1; + } + + WString NodeItemProvider::GetTextValue(vint itemIndex) + { + if (auto node = RequestNode(itemIndex)) + { + WString result = root->GetTextValue(node); + ReleaseNode(node); + return result; + } + return L""; + } + + description::Value NodeItemProvider::GetBindingValue(vint itemIndex) + { + if (auto node = RequestNode(itemIndex)) + { + Value result = root->GetBindingValue(node); + ReleaseNode(node); + return result; + } + return Value(); + } + + IDescriptable* NodeItemProvider::RequestView(const WString& identifier) + { + if(identifier==INodeItemView::Identifier) + { + return (INodeItemView*)this; + } + else + { + return root->RequestView(identifier); + } + } + +/*********************************************************************** +MemoryNodeProvider::NodeCollection +***********************************************************************/ + + void MemoryNodeProvider::NodeCollection::OnBeforeChildModified(vint start, vint count, vint newCount) + { + ownerProvider->offsetBeforeChildModified=0; + if(ownerProvider->expanding) + { + for(vint i=0;ioffsetBeforeChildModified+=items[start+i]->totalVisibleNodeCount; + } + } + INodeProviderCallback* proxy=ownerProvider->GetCallbackProxyInternal(); + if(proxy) + { + proxy->OnBeforeItemModified(ownerProvider, start, count, newCount); + } + } + + void MemoryNodeProvider::NodeCollection::OnAfterChildModified(vint start, vint count, vint newCount) + { + ownerProvider->childCount+=(newCount-count); + if(ownerProvider->expanding) + { + vint offset=0; + for(vint i=0;itotalVisibleNodeCount; + } + ownerProvider->OnChildTotalVisibleNodesChanged(offset-ownerProvider->offsetBeforeChildModified); + } + INodeProviderCallback* proxy=ownerProvider->GetCallbackProxyInternal(); + if(proxy) + { + proxy->OnAfterItemModified(ownerProvider, start, count, newCount); + } + } + + bool MemoryNodeProvider::NodeCollection::QueryInsert(vint index, Ptr const& child) + { + return child->parent == 0; + } + + bool MemoryNodeProvider::NodeCollection::QueryRemove(vint index, Ptr const& child) + { + return child->parent == ownerProvider; + } + + void MemoryNodeProvider::NodeCollection::BeforeInsert(vint index, Ptr const& child) + { + OnBeforeChildModified(index, 0, 1); + child->parent = ownerProvider; + } + + void MemoryNodeProvider::NodeCollection::BeforeRemove(vint index, Ptr const& child) + { + OnBeforeChildModified(index, 1, 0); + child->parent = 0; + } + + void MemoryNodeProvider::NodeCollection::AfterInsert(vint index, Ptr const& child) + { + OnAfterChildModified(index, 0, 1); + } + + void MemoryNodeProvider::NodeCollection::AfterRemove(vint index, vint count) + { + OnAfterChildModified(index, count, 0); + } + + MemoryNodeProvider::NodeCollection::NodeCollection() + :ownerProvider(0) + { + } + +/*********************************************************************** +MemoryNodeProvider +***********************************************************************/ + + INodeProviderCallback* MemoryNodeProvider::GetCallbackProxyInternal() + { + if(parent) + { + return parent->GetCallbackProxyInternal(); + } + else + { + return 0; + } + } + + void MemoryNodeProvider::OnChildTotalVisibleNodesChanged(vint offset) + { + totalVisibleNodeCount+=offset; + if(parent) + { + parent->OnChildTotalVisibleNodesChanged(offset); + } + } + + MemoryNodeProvider::MemoryNodeProvider(Ptr _data) + :data(_data) + { + children.ownerProvider=this; + } + + MemoryNodeProvider::~MemoryNodeProvider() + { + } + + Ptr MemoryNodeProvider::GetData() + { + return data; + } + + void MemoryNodeProvider::SetData(const Ptr& value) + { + data=value; + NotifyDataModified(); + } + + void MemoryNodeProvider::NotifyDataModified() + { + if(parent) + { + vint index=parent->children.IndexOf(this); + INodeProviderCallback* proxy=GetCallbackProxyInternal(); + if(proxy) + { + proxy->OnBeforeItemModified(parent, index, 1, 1); + proxy->OnAfterItemModified(parent, index, 1, 1); + } + } + } + + MemoryNodeProvider::NodeCollection& MemoryNodeProvider::Children() + { + return children; + } + + bool MemoryNodeProvider::GetExpanding() + { + return expanding; + } + + void MemoryNodeProvider::SetExpanding(bool value) + { + if(expanding!=value) + { + expanding=value; + vint offset=0; + for(vint i=0;itotalVisibleNodeCount; + } + + OnChildTotalVisibleNodesChanged(expanding?offset:-offset); + INodeProviderCallback* proxy=GetCallbackProxyInternal(); + if(proxy) + { + if(expanding) + { + proxy->OnItemExpanded(this); + } + else + { + proxy->OnItemCollapsed(this); + } + } + } + } + + vint MemoryNodeProvider::CalculateTotalVisibleNodes() + { + return totalVisibleNodeCount; + } + + vint MemoryNodeProvider::GetChildCount() + { + return childCount; + } + + INodeProvider* MemoryNodeProvider::GetParent() + { + return parent; + } + + INodeProvider* MemoryNodeProvider::GetChild(vint index) + { + if(0<=index && indexOnBeforeItemModified(parentNode, start, count, newCount); + } + } + + void NodeRootProviderBase::OnAfterItemModified(INodeProvider* parentNode, vint start, vint count, vint newCount) + { + for(vint i=0;iOnAfterItemModified(parentNode, start, count, newCount); + } + } + + void NodeRootProviderBase::OnItemExpanded(INodeProvider* node) + { + for(vint i=0;iOnItemExpanded(node); + } + } + + void NodeRootProviderBase::OnItemCollapsed(INodeProvider* node) + { + for(vint i=0;iOnItemCollapsed(node); + } + } + + NodeRootProviderBase::NodeRootProviderBase() + { + } + + NodeRootProviderBase::~NodeRootProviderBase() + { + } + + bool NodeRootProviderBase::CanGetNodeByVisibleIndex() + { + return false; + } + + INodeProvider* NodeRootProviderBase::GetNodeByVisibleIndex(vint index) + { + return 0; + } + + bool NodeRootProviderBase::AttachCallback(INodeProviderCallback* value) + { + if(callbacks.Contains(value)) + { + return false; + } + else + { + callbacks.Add(value); + value->OnAttached(this); + return true; + } + } + + bool NodeRootProviderBase::DetachCallback(INodeProviderCallback* value) + { + vint index=callbacks.IndexOf(value); + if(index==-1) + { + return false; + } + else + { + value->OnAttached(0); + callbacks.Remove(value); + return true; + } + } + + IDescriptable* NodeRootProviderBase::RequestView(const WString& identifier) + { + return 0; + } + +/*********************************************************************** +MemoryNodeRootProvider +***********************************************************************/ + + INodeProviderCallback* MemoryNodeRootProvider::GetCallbackProxyInternal() + { + return this; + } + + MemoryNodeRootProvider::MemoryNodeRootProvider() + { + SetExpanding(true); + } + + MemoryNodeRootProvider::~MemoryNodeRootProvider() + { + } + + INodeProvider* MemoryNodeRootProvider::GetRootNode() + { + return this; + } + + MemoryNodeProvider* MemoryNodeRootProvider::GetMemoryNode(INodeProvider* node) + { + return dynamic_cast(node); + } + } + +/*********************************************************************** +GuiVirtualTreeListControl +***********************************************************************/ + + void GuiVirtualTreeListControl::BeforeControlTemplateUninstalled_() + { + } + + void GuiVirtualTreeListControl::AfterControlTemplateInstalled_(bool initialize) + { + } + + void GuiVirtualTreeListControl::OnAttached(tree::INodeRootProvider* provider) + { + } + + void GuiVirtualTreeListControl::OnBeforeItemModified(tree::INodeProvider* parentNode, vint start, vint count, vint newCount) + { + } + + void GuiVirtualTreeListControl::OnAfterItemModified(tree::INodeProvider* parentNode, vint start, vint count, vint newCount) + { + } + + void GuiVirtualTreeListControl::OnItemExpanded(tree::INodeProvider* node) + { + GuiNodeEventArgs arguments; + (GuiEventArgs&)arguments=GetNotifyEventArguments(); + arguments.node=node; + NodeExpanded.Execute(arguments); + } + + void GuiVirtualTreeListControl::OnItemCollapsed(tree::INodeProvider* node) + { + GuiNodeEventArgs arguments; + (GuiEventArgs&)arguments=GetNotifyEventArguments(); + arguments.node=node; + NodeCollapsed.Execute(arguments); + } + + void GuiVirtualTreeListControl::OnItemMouseEvent(compositions::GuiNodeMouseEvent& nodeEvent, compositions::GuiGraphicsComposition* sender, compositions::GuiItemMouseEventArgs& arguments) + { + tree::INodeProvider* node=GetNodeItemView()->RequestNode(arguments.itemIndex); + if(node) + { + GuiNodeMouseEventArgs redirectArguments; + (GuiMouseEventArgs&)redirectArguments=arguments; + redirectArguments.node=node; + nodeEvent.Execute(redirectArguments); + (GuiMouseEventArgs&)arguments=redirectArguments; + GetNodeItemView()->ReleaseNode(node); + } + } + + void GuiVirtualTreeListControl::OnItemNotifyEvent(compositions::GuiNodeNotifyEvent& nodeEvent, compositions::GuiGraphicsComposition* sender, compositions::GuiItemEventArgs& arguments) + { + if(auto node = GetNodeItemView()->RequestNode(arguments.itemIndex)) + { + GuiNodeEventArgs redirectArguments; + (GuiEventArgs&)redirectArguments=arguments; + redirectArguments.node=node; + nodeEvent.Execute(redirectArguments); + (GuiEventArgs&)arguments=redirectArguments; + GetNodeItemView()->ReleaseNode(node); + } + } + +#define ATTACH_ITEM_MOUSE_EVENT(NODEEVENTNAME, ITEMEVENTNAME)\ + {\ + Func func(this, &GuiVirtualTreeListControl::OnItemMouseEvent);\ + ITEMEVENTNAME.AttachFunction(Curry(func)(NODEEVENTNAME));\ + }\ + +#define ATTACH_ITEM_NOTIFY_EVENT(NODEEVENTNAME, ITEMEVENTNAME)\ + {\ + Func func(this, &GuiVirtualTreeListControl::OnItemNotifyEvent);\ + ITEMEVENTNAME.AttachFunction(Curry(func)(NODEEVENTNAME));\ + }\ + + void GuiVirtualTreeListControl::OnNodeLeftButtonDoubleClick(compositions::GuiGraphicsComposition* sender, compositions::GuiNodeMouseEventArgs& arguments) + { + if (arguments.node->GetChildCount() > 0) + { + arguments.node->SetExpanding(!arguments.node->GetExpanding()); + } + } + + GuiVirtualTreeListControl::GuiVirtualTreeListControl(theme::ThemeName themeName, Ptr _nodeRootProvider) + :GuiSelectableListControl(themeName, new tree::NodeItemProvider(_nodeRootProvider)) + { + nodeItemProvider = dynamic_cast(GetItemProvider()); + nodeItemView = dynamic_cast(GetItemProvider()->RequestView(tree::INodeItemView::Identifier)); + + NodeLeftButtonDown.SetAssociatedComposition(boundsComposition); + NodeLeftButtonUp.SetAssociatedComposition(boundsComposition); + NodeLeftButtonDoubleClick.SetAssociatedComposition(boundsComposition); + NodeMiddleButtonDown.SetAssociatedComposition(boundsComposition); + NodeMiddleButtonUp.SetAssociatedComposition(boundsComposition); + NodeMiddleButtonDoubleClick.SetAssociatedComposition(boundsComposition); + NodeRightButtonDown.SetAssociatedComposition(boundsComposition); + NodeRightButtonUp.SetAssociatedComposition(boundsComposition); + NodeRightButtonDoubleClick.SetAssociatedComposition(boundsComposition); + NodeMouseMove.SetAssociatedComposition(boundsComposition); + NodeMouseEnter.SetAssociatedComposition(boundsComposition); + NodeMouseLeave.SetAssociatedComposition(boundsComposition); + NodeExpanded.SetAssociatedComposition(boundsComposition); + NodeCollapsed.SetAssociatedComposition(boundsComposition); + + ATTACH_ITEM_MOUSE_EVENT(NodeLeftButtonDown, ItemLeftButtonDown); + ATTACH_ITEM_MOUSE_EVENT(NodeLeftButtonUp, ItemLeftButtonUp); + ATTACH_ITEM_MOUSE_EVENT(NodeLeftButtonDoubleClick, ItemLeftButtonDoubleClick); + ATTACH_ITEM_MOUSE_EVENT(NodeMiddleButtonDown, ItemMiddleButtonDown); + ATTACH_ITEM_MOUSE_EVENT(NodeMiddleButtonUp, ItemMiddleButtonUp); + ATTACH_ITEM_MOUSE_EVENT(NodeMiddleButtonDoubleClick, ItemMiddleButtonDoubleClick); + ATTACH_ITEM_MOUSE_EVENT(NodeRightButtonDown, ItemRightButtonDown); + ATTACH_ITEM_MOUSE_EVENT(NodeRightButtonUp, ItemRightButtonUp); + ATTACH_ITEM_MOUSE_EVENT(NodeRightButtonDoubleClick, ItemRightButtonDoubleClick); + ATTACH_ITEM_MOUSE_EVENT(NodeMouseMove, ItemMouseMove); + ATTACH_ITEM_NOTIFY_EVENT(NodeMouseEnter, ItemMouseEnter); + ATTACH_ITEM_NOTIFY_EVENT(NodeMouseLeave, ItemMouseLeave); + + nodeItemProvider->GetRoot()->AttachCallback(this); + NodeLeftButtonDoubleClick.AttachMethod(this, &GuiVirtualTreeListControl::OnNodeLeftButtonDoubleClick); + } + +#undef ATTACH_ITEM_MOUSE_EVENT +#undef ATTACH_ITEM_NOTIFY_EVENT + + GuiVirtualTreeListControl::~GuiVirtualTreeListControl() + { + } + + tree::INodeItemView* GuiVirtualTreeListControl::GetNodeItemView() + { + return nodeItemView; + } + + tree::INodeRootProvider* GuiVirtualTreeListControl::GetNodeRootProvider() + { + return nodeItemProvider->GetRoot().Obj(); + } + + namespace tree + { + +/*********************************************************************** +TreeViewItem +***********************************************************************/ + + const wchar_t* const ITreeViewItemView::Identifier = L"vl::presentation::controls::tree::ITreeViewItemView"; + + TreeViewItem::TreeViewItem() + { + } + + TreeViewItem::TreeViewItem(const Ptr& _image, const WString& _text) + :image(_image) + ,text(_text) + { + } + +/*********************************************************************** +TreeViewItemRootProvider +***********************************************************************/ + + Ptr TreeViewItemRootProvider::GetNodeImage(INodeProvider* node) + { + MemoryNodeProvider* memoryNode=dynamic_cast(node); + if(memoryNode) + { + Ptr data=memoryNode->GetData().Cast(); + if(data) + { + return data->image; + } + } + return 0; + } + + WString TreeViewItemRootProvider::GetTextValue(INodeProvider* node) + { + MemoryNodeProvider* memoryNode = dynamic_cast(node); + if (memoryNode) + { + Ptr data = memoryNode->GetData().Cast(); + if (data) + { + return data->text; + } + } + return L""; + } + + description::Value TreeViewItemRootProvider::GetBindingValue(INodeProvider* node) + { + return Value::From(GetTreeViewData(node)); + } + + TreeViewItemRootProvider::TreeViewItemRootProvider() + { + } + + TreeViewItemRootProvider::~TreeViewItemRootProvider() + { + } + + IDescriptable* TreeViewItemRootProvider::RequestView(const WString& identifier) + { + if(identifier==ITreeViewItemView::Identifier) + { + return (ITreeViewItemView*)this; + } + else + { + return MemoryNodeRootProvider::RequestView(identifier); + } + } + + Ptr TreeViewItemRootProvider::GetTreeViewData(INodeProvider* node) + { + MemoryNodeProvider* memoryNode=GetMemoryNode(node); + if(memoryNode) + { + return memoryNode->GetData().Cast(); + } + else + { + return 0; + } + } + + void TreeViewItemRootProvider::SetTreeViewData(INodeProvider* node, Ptr value) + { + MemoryNodeProvider* memoryNode=GetMemoryNode(node); + if(memoryNode) + { + memoryNode->SetData(value); + } + } + + void TreeViewItemRootProvider::UpdateTreeViewData(INodeProvider* node) + { + MemoryNodeProvider* memoryNode=GetMemoryNode(node); + if(memoryNode) + { + memoryNode->NotifyDataModified(); + } + } + } + +/*********************************************************************** +GuiVirtualTreeView +***********************************************************************/ + + templates::GuiTreeItemTemplate* GuiVirtualTreeView::GetStyleFromNode(tree::INodeProvider* node) + { + if (itemArranger) + { + vint index = nodeItemView->CalculateNodeVisibilityIndex(node); + if (index != -1) + { + auto style = itemArranger->GetVisibleStyle(index); + return dynamic_cast(style); + } + } + return nullptr; + } + + void GuiVirtualTreeView::SetStyleExpanding(tree::INodeProvider* node, bool expanding) + { + if (auto treeItemStyle = GetStyleFromNode(node)) + { + treeItemStyle->SetExpanding(expanding); + } + } + + void GuiVirtualTreeView::SetStyleExpandable(tree::INodeProvider* node, bool expandable) + { + if (auto treeItemStyle = GetStyleFromNode(node)) + { + treeItemStyle->SetExpandable(expandable); + } + } + + void GuiVirtualTreeView::OnAfterItemModified(tree::INodeProvider* parentNode, vint start, vint count, vint newCount) + { + GuiVirtualTreeListControl::OnAfterItemModified(parentNode, start, count, newCount); + SetStyleExpandable(parentNode, parentNode->GetChildCount() > 0); + } + + void GuiVirtualTreeView::OnItemExpanded(tree::INodeProvider* node) + { + GuiVirtualTreeListControl::OnItemExpanded(node); + SetStyleExpanding(node, true); + } + + void GuiVirtualTreeView::OnItemCollapsed(tree::INodeProvider* node) + { + GuiVirtualTreeListControl::OnItemCollapsed(node); + SetStyleExpanding(node, false); + } + + void GuiVirtualTreeView::OnStyleInstalled(vint itemIndex, ItemStyle* style) + { + GuiVirtualTreeListControl::OnStyleInstalled(itemIndex, style); + if (auto treeItemStyle = dynamic_cast(style)) + { + treeItemStyle->SetTextColor(GetControlTemplateObject()->GetTextColor()); + + if (treeViewItemView) + { + if (auto node = nodeItemView->RequestNode(itemIndex)) + { + treeItemStyle->SetImage(treeViewItemView->GetNodeImage(node)); + treeItemStyle->SetExpanding(node->GetExpanding()); + treeItemStyle->SetExpandable(node->GetChildCount() > 0); + { + vint level = -1; + auto current = node; + while (current->GetParent()) + { + level++; + current = current->GetParent(); + } + treeItemStyle->SetLevel(level); + } + nodeItemView->ReleaseNode(node); + } + } + } + } + + GuiVirtualTreeView::GuiVirtualTreeView(theme::ThemeName themeName, Ptr _nodeRootProvider) + :GuiVirtualTreeListControl(themeName, _nodeRootProvider) + { + treeViewItemView = dynamic_cast(GetNodeRootProvider()->RequestView(tree::ITreeViewItemView::Identifier)); + SetStyleAndArranger( + [](const Value&) { return new tree::DefaultTreeItemTemplate; }, + new list::FixedHeightItemArranger + ); + } + + GuiVirtualTreeView::~GuiVirtualTreeView() + { + } + +/*********************************************************************** +GuiTreeView +***********************************************************************/ + + GuiTreeView::GuiTreeView(theme::ThemeName themeName) + :GuiVirtualTreeView(themeName, new tree::TreeViewItemRootProvider) + { + nodes = nodeItemProvider->GetRoot().Cast(); + } + + GuiTreeView::~GuiTreeView() + { + } + + Ptr GuiTreeView::Nodes() + { + return nodes; + } + + Ptr GuiTreeView::GetSelectedItem() + { + Ptr result; + vint index = GetSelectedItemIndex(); + if (index != -1) + { + if (auto node = nodeItemView->RequestNode(index)) + { + if (auto memoryNode = dynamic_cast(node)) + { + result = memoryNode->GetData().Cast(); + } + nodeItemView->ReleaseNode(node); + } + } + return result; + } + + namespace tree + { + +/*********************************************************************** +DefaultTreeItemTemplate +***********************************************************************/ + + void DefaultTreeItemTemplate::OnInitialize() + { + templates::GuiTreeItemTemplate::OnInitialize(); + SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + + table = new GuiTableComposition; + AddChild(table); + table->SetRowsAndColumns(3, 4); + table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); + table->SetRowOption(1, GuiCellOption::MinSizeOption()); + table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); + table->SetColumnOption(0, GuiCellOption::AbsoluteOption(0)); + table->SetColumnOption(1, GuiCellOption::MinSizeOption()); + table->SetColumnOption(2, GuiCellOption::MinSizeOption()); + table->SetColumnOption(3, GuiCellOption::MinSizeOption()); + table->SetAlignmentToParent(Margin(0, 0, 0, 0)); + table->SetCellPadding(2); + { + GuiCellComposition* cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(0, 1, 3, 1); + cell->SetPreferredMinSize(Size(16, 16)); + + expandingButton = new GuiSelectableButton(theme::ThemeName::TreeItemExpander); + if (auto treeView = dynamic_cast(listControl)) + { + if (auto expanderStyle = treeView->GetControlTemplateObject()->GetExpandingDecoratorTemplate()) + { + expandingButton->SetControlTemplate(expanderStyle); + } + } + expandingButton->SetAutoSelection(false); + expandingButton->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); + expandingButton->GetBoundsComposition()->GetEventReceiver()->leftButtonDoubleClick.AttachMethod(this, &DefaultTreeItemTemplate::OnExpandingButtonDoubleClick); + expandingButton->Clicked.AttachMethod(this, &DefaultTreeItemTemplate::OnExpandingButtonClicked); + cell->AddChild(expandingButton->GetBoundsComposition()); + } + { + GuiCellComposition* cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(1, 2, 1, 1); + cell->SetPreferredMinSize(Size(16, 16)); + + imageElement = GuiImageFrameElement::Create(); + imageElement->SetStretch(true); + cell->SetOwnedElement(imageElement); + } + { + GuiCellComposition* cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(0, 3, 3, 1); + cell->SetPreferredMinSize(Size(192, 0)); + + textElement = GuiSolidLabelElement::Create(); + textElement->SetAlignments(Alignment::Left, Alignment::Center); + textElement->SetEllipse(true); + cell->SetOwnedElement(textElement); + } + + FontChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnFontChanged); + TextChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnTextChanged); + TextColorChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnTextColorChanged); + ExpandingChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnExpandingChanged); + ExpandableChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnExpandableChanged); + LevelChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnLevelChanged); + ImageChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnImageChanged); + + FontChanged.Execute(compositions::GuiEventArgs(this)); + TextChanged.Execute(compositions::GuiEventArgs(this)); + TextColorChanged.Execute(compositions::GuiEventArgs(this)); + ExpandingChanged.Execute(compositions::GuiEventArgs(this)); + ExpandableChanged.Execute(compositions::GuiEventArgs(this)); + LevelChanged.Execute(compositions::GuiEventArgs(this)); + ImageChanged.Execute(compositions::GuiEventArgs(this)); + } + + void DefaultTreeItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + textElement->SetFont(GetFont()); + } + + void DefaultTreeItemTemplate::OnTextChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + textElement->SetText(GetText()); + } + + void DefaultTreeItemTemplate::OnTextColorChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + textElement->SetColor(GetTextColor()); + } + + void DefaultTreeItemTemplate::OnExpandingChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + expandingButton->SetSelected(GetExpanding()); + } + + void DefaultTreeItemTemplate::OnExpandableChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + expandingButton->SetVisible(GetExpandable()); + } + + void DefaultTreeItemTemplate::OnLevelChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + table->SetColumnOption(0, GuiCellOption::AbsoluteOption(GetLevel() * 12)); + } + + void DefaultTreeItemTemplate::OnImageChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if (auto imageData = GetImage()) + { + imageElement->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); + } + else + { + imageElement->SetImage(nullptr); + } + } + + void DefaultTreeItemTemplate::OnExpandingButtonDoubleClick(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) + { + arguments.handled = true; + } + + void DefaultTreeItemTemplate::OnExpandingButtonClicked(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if (expandingButton->GetVisuallyEnabled()) + { + if (auto treeControl = dynamic_cast(listControl)) + { + if (auto view = treeControl->GetNodeItemView()) + { + vint index = treeControl->GetArranger()->GetVisibleIndex(this); + if (index != -1) + { + if (auto node = view->RequestNode(index)) + { + bool expanding = node->GetExpanding(); + node->SetExpanding(!expanding); + view->ReleaseNode(node); + } + } + } + } + } + } + + DefaultTreeItemTemplate::DefaultTreeItemTemplate() + { + } + + DefaultTreeItemTemplate::~DefaultTreeItemTemplate() + { + } + } + } + } +} + /*********************************************************************** .\CONTROLS\GUIDATETIMECONTROLS.CPP ***********************************************************************/ @@ -10866,6 +15933,7 @@ GuiDatePicker::CommandExecutor void GuiDatePicker::CommandExecutor::NotifyDateChanged() { + datePicker->date = datePicker->GetControlTemplateObject()->GetDate(); datePicker->UpdateText(); datePicker->DateChanged.Execute(datePicker->GetNotifyEventArguments()); } @@ -11216,6 +16284,21 @@ GuiComboBoxListControl InstallStyleController(itemIndex); } + void GuiComboBoxListControl::AdoptSubMenuSize() + { + Size expectedSize(0, GetFont().size * 20); + Size adoptedSize = containedListControl->GetAdoptedSize(expectedSize); + + Size clientSize = GetPreferredMenuClientSize(); + clientSize.y = adoptedSize.y + GetSubMenu()->GetClientSize().y - containedListControl->GetBoundsComposition()->GetBounds().Height(); + SetPreferredMenuClientSize(clientSize); + + if (GetSubMenuOpening()) + { + GetSubMenu()->SetClientSize(clientSize); + } + } + void GuiComboBoxListControl::OnTextChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { if (itemStyleController) @@ -11230,8 +16313,7 @@ GuiComboBoxListControl { itemStyleController->SetFont(GetFont()); } - auto args = GetNotifyEventArguments(); - OnListControlAdoptedSizeInvalidated(nullptr, args); + AdoptSubMenuSize(); } void GuiComboBoxListControl::OnVisuallyEnabledChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) @@ -11244,17 +16326,15 @@ GuiComboBoxListControl void GuiComboBoxListControl::OnListControlAdoptedSizeInvalidated(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - Size expectedSize(0, GetFont().size * 20); - Size adoptedSize = containedListControl->GetAdoptedSize(expectedSize); + AdoptSubMenuSize(); + } - Size clientSize = GetPreferredMenuClientSize(); - clientSize.y = adoptedSize.y + GetSubMenu()->GetClientSize().y - containedListControl->GetBoundsComposition()->GetBounds().Height(); - SetPreferredMenuClientSize(clientSize); - - if (GetSubMenuOpening()) + void GuiComboBoxListControl::OnListControlBoundsChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + GetApplication()->InvokeLambdaInMainThread([=]() { - GetSubMenu()->SetClientSize(clientSize); - } + AdoptSubMenuSize(); + }); } void GuiComboBoxListControl::OnListControlSelectionChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) @@ -11275,6 +16355,7 @@ GuiComboBoxListControl containedListControl->SetMultiSelect(false); containedListControl->AdoptedSizeInvalidated.AttachMethod(this, &GuiComboBoxListControl::OnListControlAdoptedSizeInvalidated); containedListControl->SelectionChanged.AttachMethod(this, &GuiComboBoxListControl::OnListControlSelectionChanged); + boundsChangedHandler = containedListControl->GetBoundsComposition()->BoundsChanged.AttachMethod(this, &GuiComboBoxListControl::OnListControlBoundsChanged); auto itemProvider = containedListControl->GetItemProvider(); @@ -11287,6 +16368,8 @@ GuiComboBoxListControl GuiComboBoxListControl::~GuiComboBoxListControl() { + containedListControl->GetBoundsComposition()->BoundsChanged.Detach(boundsChangedHandler); + boundsChangedHandler = nullptr; } GuiSelectableListControl* GuiComboBoxListControl::GetContainedListControl() @@ -11345,21 +16428,746 @@ GuiComboBoxListControl /*********************************************************************** -.\CONTROLS\TEXTEDITORPACKAGE\EDITORCALLBACK\GUITEXTGENERALOPERATIONS.CPP +.\CONTROLS\TEMPLATES\GUICOMMONTEMPLATES.CPP ***********************************************************************/ namespace vl { namespace presentation { - namespace controls + namespace templates { + using namespace elements; + using namespace compositions; + using namespace templates; + using namespace controls; + using namespace theme; + +/*********************************************************************** +GuiCommonDatePickerLook +***********************************************************************/ + + vint GetDayCountForMonth(vint year, vint month) + { + bool isLeapYear = (year % 100 == 0) ? (year % 400 == 0) : (year % 4 == 0); + switch (month) + { + case 1:case 3:case 5:case 7:case 8:case 10:case 12: + return 31; + case 4:case 6:case 9:case 11: + return 30; + default: + return isLeapYear ? 29 : 28; + } + } + + void StepPreviousMonth(vint& year, vint& month) + { + if (month == 1) + { + year--; + month = 12; + } + else + { + month--; + } + } + + void StepNextMonth(vint& year, vint& month) + { + if (month == 12) + { + year++; + month = 1; + } + else + { + month++; + } + } + + void GuiCommonDatePickerLook::SetDay(const DateTime& day, vint& index, bool currentMonth) + { + dateDays[index] = day; + GuiSolidLabelElement* label = labelDays[index]; + label->SetText(itow(day.day)); + label->SetColor(currentMonth ? primaryTextColor : secondaryTextColor); + index++; + } + + void GuiCommonDatePickerLook::comboYearMonth_SelectedIndexChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if (!preventComboEvent) + { + if (comboYear->GetSelectedIndex() != -1 && comboMonth->GetSelectedIndex() != -1) + { + vint year = comboYear->GetSelectedIndex() + YearFirst; + vint month = comboMonth->GetSelectedIndex() + 1; + SetDate(DateTime::FromDateTime(year, month, 1)); + + GuiEventArgs arguments(this); + DateChanged.Execute(arguments); + commands->NotifyDateChanged(); + commands->NotifyDateNavigated(); + } + } + } + + void GuiCommonDatePickerLook::buttonDay_SelectedChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if (!preventButtonEvent) + { + GuiSelectableButton* button = dynamic_cast(sender->GetRelatedControl()); + if (button->GetSelected()) + { + vint index = buttonDays.IndexOf(button); + if (index != -1) + { + DateTime day = dateDays[index]; + if (day.year != currentDate.year || day.month != currentDate.month) + { + SetDate(day); + } + else + { + currentDate = day; + } + + GuiEventArgs arguments(this); + DateChanged.Execute(arguments); + commands->NotifyDateChanged(); + commands->NotifyDateSelected(); + } + } + } + } + + void GuiCommonDatePickerLook::DisplayMonth(vint year, vint month) + { + if (YearFirst <= year && year <= YearLast && 1 <= month && month <= 12) + { + preventComboEvent = true; + comboYear->SetSelectedIndex(year - YearFirst); + comboMonth->SetSelectedIndex(month - 1); + preventComboEvent = false; + } + + vint yearPrev = year, yearNext = year, monthPrev = month, monthNext = month; + StepPreviousMonth(yearPrev, monthPrev); + StepNextMonth(yearNext, monthNext); + + vint countPrev = GetDayCountForMonth(yearPrev, monthPrev); + vint count = GetDayCountForMonth(year, month); + vint countNext = GetDayCountForMonth(yearNext, monthNext); + + DateTime firstDay = DateTime::FromDateTime(year, month, 1); + vint showPrev = firstDay.dayOfWeek; + if (showPrev == 0) showPrev = DaysOfWeek; + vint show = count; + vint showNext = DaysOfWeek*DayRows - showPrev - show; + + vint index = 0; + for (vint i = 0; i < showPrev; i++) + { + DateTime day = DateTime::FromDateTime(yearPrev, monthPrev, countPrev - (showPrev - i - 1)); + SetDay(day, index, false); + } + for (vint i = 0; i < show; i++) + { + DateTime day = DateTime::FromDateTime(year, month, i + 1); + SetDay(day, index, true); + } + for (vint i = 0; i < showNext; i++) + { + DateTime day = DateTime::FromDateTime(yearNext, monthNext, i + 1); + SetDay(day, index, false); + } + } + + void GuiCommonDatePickerLook::SelectDay(vint day) + { + for (vint i = 0; i < dateDays.Count(); i++) + { + const DateTime& dt = dateDays[i]; + if (dt.year == currentDate.year && dt.month == currentDate.month && dt.day == day) + { + preventButtonEvent = true; + buttonDays[i]->SetSelected(true); + preventButtonEvent = false; + break; + } + } + } + + GuiCommonDatePickerLook::GuiCommonDatePickerLook(Color _backgroundColor, Color _primaryTextColor, Color _secondaryTextColor) + :backgroundColor(_backgroundColor) + , primaryTextColor(_primaryTextColor) + , secondaryTextColor(_secondaryTextColor) + { + DateChanged.SetAssociatedComposition(this); + SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + + GuiTableComposition* monthTable = 0; + GuiTableComposition* dayTable = 0; + { + listYears = new GuiTextList(theme::ThemeName::TextList); + listYears->SetHorizontalAlwaysVisible(false); + for (vint i = YearFirst; i <= YearLast; i++) + { + listYears->GetItems().Add(new list::TextItem(itow(i))); + } + comboYear = new GuiComboBoxListControl(theme::ThemeName::ComboBox, listYears); + comboYear->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 2, 0)); + comboYear->SelectedIndexChanged.AttachMethod(this, &GuiCommonDatePickerLook::comboYearMonth_SelectedIndexChanged); + } + { + listMonths = new GuiTextList(theme::ThemeName::TextList); + listMonths->SetHorizontalAlwaysVisible(false); + comboMonth = new GuiComboBoxListControl(theme::ThemeName::ComboBox, listMonths); + comboMonth->GetBoundsComposition()->SetAlignmentToParent(Margin(2, 0, 0, 0)); + comboMonth->SelectedIndexChanged.AttachMethod(this, &GuiCommonDatePickerLook::comboYearMonth_SelectedIndexChanged); + } + { + monthTable = new GuiTableComposition; + monthTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); + monthTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + monthTable->SetRowsAndColumns(1, 2); + monthTable->SetRowOption(0, GuiCellOption::MinSizeOption()); + monthTable->SetColumnOption(0, GuiCellOption::PercentageOption(0.5)); + monthTable->SetColumnOption(1, GuiCellOption::PercentageOption(0.5)); + { + GuiCellComposition* cell = new GuiCellComposition; + monthTable->AddChild(cell); + cell->SetSite(0, 0, 1, 1); + cell->AddChild(comboYear->GetBoundsComposition()); + } + { + GuiCellComposition* cell = new GuiCellComposition; + monthTable->AddChild(cell); + cell->SetSite(0, 1, 1, 1); + cell->AddChild(comboMonth->GetBoundsComposition()); + } + } + { + dayTable = new GuiTableComposition; + dayTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + dayTable->SetCellPadding(4); + dayTable->SetRowsAndColumns(DayRows + DayRowStart, DaysOfWeek); + + for (vint i = 0; i < DayRowStart; i++) + { + dayTable->SetRowOption(i, GuiCellOption::MinSizeOption()); + } + for (vint i = 0; i < DayRows; i++) + { + dayTable->SetRowOption(i + DayRowStart, GuiCellOption::PercentageOption(1.0)); + } + for (vint i = 0; i < DaysOfWeek; i++) + { + dayTable->SetColumnOption(i, GuiCellOption::PercentageOption(1.0)); + } + + { + GuiCellComposition* cell = new GuiCellComposition; + dayTable->AddChild(cell); + cell->SetSite(0, 0, 1, DaysOfWeek); + cell->AddChild(monthTable); + } + + labelDaysOfWeek.Resize(7); + for (vint i = 0; i < DaysOfWeek; i++) + { + GuiCellComposition* cell = new GuiCellComposition; + dayTable->AddChild(cell); + cell->SetSite(1, i, 1, 1); + + GuiSolidLabelElement* element = GuiSolidLabelElement::Create(); + element->SetAlignments(Alignment::Center, Alignment::Center); + element->SetColor(primaryTextColor); + labelDaysOfWeek[i] = element; + cell->SetOwnedElement(element); + } + + buttonDays.Resize(DaysOfWeek*DayRows); + labelDays.Resize(DaysOfWeek*DayRows); + dateDays.Resize(DaysOfWeek*DayRows); + + auto dayMutexController = new GuiSelectableButton::MutexGroupController; + AddComponent(dayMutexController); + + for (vint i = 0; i < DaysOfWeek; i++) + { + for (vint j = 0; j < DayRows; j++) + { + GuiCellComposition* cell = new GuiCellComposition; + dayTable->AddChild(cell); + cell->SetSite(j + DayRowStart, i, 1, 1); + + GuiSelectableButton* button = new GuiSelectableButton(theme::ThemeName::CheckBox); + button->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); + button->SetGroupController(dayMutexController); + button->SelectedChanged.AttachMethod(this, &GuiCommonDatePickerLook::buttonDay_SelectedChanged); + cell->AddChild(button->GetBoundsComposition()); + buttonDays[j*DaysOfWeek + i] = button; + + GuiSolidLabelElement* element = GuiSolidLabelElement::Create(); + element->SetAlignments(Alignment::Center, Alignment::Center); + element->SetText(L"0"); + labelDays[j*DaysOfWeek + i] = element; + + GuiBoundsComposition* elementBounds = new GuiBoundsComposition; + elementBounds->SetOwnedElement(element); + elementBounds->SetAlignmentToParent(Margin(0, 0, 0, 0)); + elementBounds->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElement); + button->GetContainerComposition()->AddChild(elementBounds); + } + } + } + { + GuiSolidBackgroundElement* element = GuiSolidBackgroundElement::Create(); + element->SetColor(backgroundColor); + dayTable->SetOwnedElement(element); + } + + dayTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); + AddChild(dayTable); + + SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + SetFont(font); + } + + GuiCommonDatePickerLook::~GuiCommonDatePickerLook() + { + FinalizeInstanceRecursively(this); + } + + controls::IDatePickerCommandExecutor* GuiCommonDatePickerLook::GetCommands() + { + return commands; + } + + void GuiCommonDatePickerLook::SetCommands(controls::IDatePickerCommandExecutor* value) + { + commands = value; + } + + TemplateProperty GuiCommonDatePickerLook::GetDateButtonTemplate() + { + return dateButtonTemplate; + } + + void GuiCommonDatePickerLook::SetDateButtonTemplate(const TemplateProperty& value) + { + dateButtonTemplate = value; + FOREACH(GuiSelectableButton*, button, buttonDays) + { + button->SetControlTemplate(value); + } + } + + TemplateProperty GuiCommonDatePickerLook::GetDateTextListTemplate() + { + return dateTextListTemplate; + } + + void GuiCommonDatePickerLook::SetDateTextListTemplate(const TemplateProperty& value) + { + dateTextListTemplate = value; + listYears->SetControlTemplate(value); + listMonths->SetControlTemplate(value); + } + + TemplateProperty GuiCommonDatePickerLook::GetDateComboBoxTemplate() + { + return dateComboBoxTemplate; + } + + void GuiCommonDatePickerLook::SetDateComboBoxTemplate(const TemplateProperty& value) + { + dateComboBoxTemplate = value; + comboYear->SetControlTemplate(value); + comboMonth->SetControlTemplate(value); + } + + const Locale& GuiCommonDatePickerLook::GetDateLocale() + { + return dateLocale; + } + + void GuiCommonDatePickerLook::SetDateLocale(const Locale& value) + { + if (dateLocale != value) + { + dateLocale = value; + for (vint i = 0; i < DaysOfWeek; i++) + { + labelDaysOfWeek[i]->SetText(dateLocale.GetShortDayOfWeekName(i)); + } + + listMonths->GetItems().Clear(); + for (vint i = 1; i <= 12; i++) + { + listMonths->GetItems().Add(new list::TextItem(dateLocale.GetLongMonthName(i))); + } + + SetDate(currentDate); + } + } + + const DateTime& GuiCommonDatePickerLook::GetDate() + { + return currentDate; + } + + void GuiCommonDatePickerLook::SetDate(const DateTime& value) + { + currentDate = value; + DisplayMonth(value.year, value.month); + SelectDay(value.day); + } + + const FontProperties& GuiCommonDatePickerLook::GetFont() + { + return font; + } + + void GuiCommonDatePickerLook::SetFont(const FontProperties& value) + { + if (font != value) + { + font = value; + comboYear->SetFont(value); + listYears->SetFont(value); + comboMonth->SetFont(value); + listMonths->SetFont(value); + FOREACH(GuiSolidLabelElement*, label, From(labelDaysOfWeek).Concat(labelDays)) + { + label->SetFont(value); + } + } + } + +/*********************************************************************** +GuiCommonDatePickerLook +***********************************************************************/ + + void GuiCommonScrollViewLook::UpdateTable() + { + if (horizontalScroll->GetVisible()) + { + tableComposition->SetRowOption(1, GuiCellOption::AbsoluteOption(defaultScrollSize)); + } + else + { + tableComposition->SetRowOption(1, GuiCellOption::AbsoluteOption(0)); + } + + if (verticalScroll->GetVisible()) + { + tableComposition->SetColumnOption(1, GuiCellOption::AbsoluteOption(defaultScrollSize)); + } + else + { + tableComposition->SetColumnOption(1, GuiCellOption::AbsoluteOption(0)); + } + + tableComposition->UpdateCellBounds(); + } + + void GuiCommonScrollViewLook::hScroll_OnVisibleChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + UpdateTable(); + } + + void GuiCommonScrollViewLook::vScroll_OnVisibleChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + UpdateTable(); + } + + GuiCommonScrollViewLook::GuiCommonScrollViewLook(vint _defaultScrollSize) + :defaultScrollSize(_defaultScrollSize) + { + SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + + horizontalScroll = new GuiScroll(theme::ThemeName::HScroll); + horizontalScroll->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); + horizontalScroll->SetEnabled(false); + verticalScroll = new GuiScroll(theme::ThemeName::HScroll); + verticalScroll->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); + verticalScroll->SetEnabled(false); + + tableComposition = new GuiTableComposition; + AddChild(tableComposition); + tableComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + tableComposition->SetRowsAndColumns(2, 2); + tableComposition->SetRowOption(0, GuiCellOption::PercentageOption(1.0)); + tableComposition->SetRowOption(1, GuiCellOption::MinSizeOption()); + tableComposition->SetColumnOption(0, GuiCellOption::PercentageOption(1.0)); + tableComposition->SetColumnOption(1, GuiCellOption::MinSizeOption()); + UpdateTable(); + { + GuiCellComposition* cell = new GuiCellComposition; + tableComposition->AddChild(cell); + cell->SetSite(1, 0, 1, 1); + cell->AddChild(horizontalScroll->GetBoundsComposition()); + } + { + GuiCellComposition* cell = new GuiCellComposition; + tableComposition->AddChild(cell); + cell->SetSite(0, 1, 1, 1); + cell->AddChild(verticalScroll->GetBoundsComposition()); + } + + containerCellComposition = new GuiCellComposition; + tableComposition->AddChild(containerCellComposition); + containerCellComposition->SetSite(0, 0, 1, 1); + + containerComposition = new GuiBoundsComposition; + containerComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + containerCellComposition->AddChild(containerComposition); + + horizontalScroll->VisibleChanged.AttachMethod(this, &GuiCommonScrollViewLook::hScroll_OnVisibleChanged); + verticalScroll->VisibleChanged.AttachMethod(this, &GuiCommonScrollViewLook::vScroll_OnVisibleChanged); + UpdateTable(); + } + + GuiCommonScrollViewLook::~GuiCommonScrollViewLook() + { + } + + controls::GuiScroll* GuiCommonScrollViewLook::GetHScroll() + { + return horizontalScroll; + } + + controls::GuiScroll* GuiCommonScrollViewLook::GetVScroll() + { + return verticalScroll; + } + + compositions::GuiGraphicsComposition* GuiCommonScrollViewLook::GetContainerComposition() + { + return containerComposition; + } + + TemplateProperty GuiCommonScrollViewLook::GetHScrollTemplate() + { + return hScrollTemplate; + } + + void GuiCommonScrollViewLook::SetHScrollTemplate(const TemplateProperty& value) + { + hScrollTemplate = value; + horizontalScroll->SetControlTemplate(value); + } + + TemplateProperty GuiCommonScrollViewLook::GetVScrollTemplate() + { + return vScrollTemplate; + } + + void GuiCommonScrollViewLook::SetVScrollTemplate(const TemplateProperty& value) + { + vScrollTemplate = value; + verticalScroll->SetControlTemplate(value); + } + +/*********************************************************************** +GuiCommonScrollBehavior +***********************************************************************/ + + void GuiCommonScrollBehavior::SetScroll(vint totalPixels, vint newOffset) + { + vint totalSize = scrollTemplate->GetTotalSize(); + double ratio = (double)newOffset / totalPixels; + vint newPosition = (vint)round(ratio * totalSize); + + vint offset1 = (vint)round(((double)newPosition / totalSize) * totalPixels); + vint offset2 = (vint)round(((double)(newPosition + 1)) / totalSize * totalPixels); + vint delta1 = offset1 - newOffset; + vint delta2 = offset2 - newOffset; + + if (delta1 < 0) { delta1 = -delta1; } + if (delta2 < 0) { delta2 = -delta2; } + + if (delta1 < delta2) + { + scrollTemplate->GetCommands()->SetPosition(newPosition); + } + else + { + scrollTemplate->GetCommands()->SetPosition(newPosition + 1); + } + } + + void GuiCommonScrollBehavior::AttachHandle(compositions::GuiGraphicsComposition* handle) + { + handle->GetEventReceiver()->leftButtonDown.AttachLambda([=](GuiGraphicsComposition*, GuiMouseEventArgs& arguments) + { + if (scrollTemplate->GetVisuallyEnabled()) + { + dragging = true; + location.x = arguments.x; + location.y = arguments.y; + } + }); + + handle->GetEventReceiver()->leftButtonUp.AttachLambda([=](GuiGraphicsComposition*, GuiMouseEventArgs&) + { + if (scrollTemplate->GetVisuallyEnabled()) + { + dragging = false; + } + }); + } + + GuiCommonScrollBehavior::GuiCommonScrollBehavior() + { + } + + GuiCommonScrollBehavior::~GuiCommonScrollBehavior() + { + } + + void GuiCommonScrollBehavior::AttachScrollTemplate(GuiScrollTemplate* value) + { + scrollTemplate = value; + } + + void GuiCommonScrollBehavior::AttachDecreaseButton(controls::GuiButton* button) + { + button->Clicked.AttachLambda([=](GuiGraphicsComposition*, GuiEventArgs&) + { + scrollTemplate->GetCommands()->SmallDecrease(); + }); + } + + void GuiCommonScrollBehavior::AttachIncreaseButton(controls::GuiButton* button) + { + button->Clicked.AttachLambda([=](GuiGraphicsComposition*, GuiEventArgs&) + { + scrollTemplate->GetCommands()->SmallIncrease(); + }); + } + + void GuiCommonScrollBehavior::AttachHorizontalPartialView(compositions::GuiPartialViewComposition* partialView) + { + partialView->GetParent()->GetEventReceiver()->leftButtonDown.AttachLambda([=](GuiGraphicsComposition*, GuiMouseEventArgs& arguments) + { + if (scrollTemplate->GetVisuallyEnabled()) + { + if (arguments.x < partialView->GetBounds().x1) + { + scrollTemplate->GetCommands()->BigDecrease(); + } + else if (arguments.x >= partialView->GetBounds().x2) + { + scrollTemplate->GetCommands()->BigIncrease(); + } + } + }); + + partialView->GetEventReceiver()->mouseMove.AttachLambda([=](GuiGraphicsComposition*, GuiMouseEventArgs& arguments) + { + if (dragging) + { + auto bounds = partialView->GetParent()->GetBounds(); + vint totalPixels = bounds.x2 - bounds.x1; + vint currentOffset = partialView->GetBounds().x1; + vint newOffset = currentOffset + (arguments.x - location.x); + SetScroll(totalPixels, newOffset); + } + }); + + AttachHandle(partialView); + } + + void GuiCommonScrollBehavior::AttachVerticalPartialView(compositions::GuiPartialViewComposition* partialView) + { + partialView->GetParent()->GetEventReceiver()->leftButtonDown.AttachLambda([=](GuiGraphicsComposition*, GuiMouseEventArgs& arguments) + { + if (scrollTemplate->GetVisuallyEnabled()) + { + if (arguments.y < partialView->GetBounds().y1) + { + scrollTemplate->GetCommands()->BigDecrease(); + } + else if (arguments.y >= partialView->GetBounds().y2) + { + scrollTemplate->GetCommands()->BigIncrease(); + } + } + }); + + partialView->GetEventReceiver()->mouseMove.AttachLambda([=](GuiGraphicsComposition*, GuiMouseEventArgs& arguments) + { + if (dragging) + { + auto bounds = partialView->GetParent()->GetBounds(); + vint totalPixels = bounds.y2 - bounds.y1; + vint currentOffset = partialView->GetBounds().y1; + vint newOffset = currentOffset + (arguments.y - location.y); + SetScroll(totalPixels, newOffset); + } + }); + + AttachHandle(partialView); + } + + void GuiCommonScrollBehavior::AttachHorizontalTrackerHandle(compositions::GuiBoundsComposition* handle) + { + handle->GetEventReceiver()->mouseMove.AttachLambda([=](GuiGraphicsComposition*, GuiMouseEventArgs& arguments) + { + if (dragging) + { + auto bounds = handle->GetParent()->GetBounds(); + vint totalPixels = bounds.x2 - bounds.x1; + vint currentOffset = handle->GetBounds().x1; + vint newOffset = currentOffset + (arguments.x - location.x); + SetScroll(totalPixels, newOffset); + } + }); + + AttachHandle(handle); + } + + void GuiCommonScrollBehavior::AttachVerticalTrackerHandle(compositions::GuiBoundsComposition* handle) + { + handle->GetEventReceiver()->mouseMove.AttachLambda([=](GuiGraphicsComposition*, GuiMouseEventArgs& arguments) + { + if (dragging) + { + auto bounds = handle->GetParent()->GetBounds(); + vint totalPixels = bounds.y2 - bounds.y1; + vint currentOffset = handle->GetBounds().y1; + vint newOffset = currentOffset + (arguments.y - location.y); + SetScroll(totalPixels, newOffset); + } + }); + + AttachHandle(handle); + } + + vint GuiCommonScrollBehavior::GetHorizontalTrackerHandlerPosition(compositions::GuiBoundsComposition* handle, vint totalSize, vint pageSize, vint position) + { + vint width = handle->GetParent()->GetBounds().Width() - handle->GetBounds().Width(); + vint max = totalSize - pageSize; + return max == 0 ? 0 : width * position / max; + } + + vint GuiCommonScrollBehavior::GetVerticalTrackerHandlerPosition(compositions::GuiBoundsComposition* handle, vint totalSize, vint pageSize, vint position) + { + vint height = handle->GetParent()->GetBounds().Height() - handle->GetBounds().Height(); + vint max = totalSize - pageSize; + return max == 0 ? 0 : height * position / max; + } } } } /*********************************************************************** -.\CONTROLS\TEXTEDITORPACKAGE\EDITORCALLBACK\GUITEXTCOLORIZER.CPP +.\CONTROLS\TOOLSTRIPPACKAGE\GUIMENUCONTROLS.CPP ***********************************************************************/ namespace vl @@ -11368,3190 +17176,968 @@ namespace vl { namespace controls { - using namespace elements; - using namespace elements::text; + using namespace compositions; /*********************************************************************** -GuiTextBoxColorizerBase +IGuiMenuService ***********************************************************************/ - void GuiTextBoxColorizerBase::ColorizerThreadProc(void* argument) + const wchar_t* const IGuiMenuService::Identifier = L"vl::presentation::controls::IGuiMenuService"; + + IGuiMenuService::IGuiMenuService() + :openingMenu(0) { - GuiTextBoxColorizerBase* colorizer=(GuiTextBoxColorizerBase*)argument; - while(!colorizer->isFinalizing) - { - vint lineIndex=-1; - wchar_t* text=0; - vuint32_t* colors=0; - vint length=0; - vint lexerState=-1; - vint contextState=-1; - - SPIN_LOCK(*colorizer->elementModifyLock) - { - if(colorizer->colorizedLineCount>=colorizer->element->GetLines().GetCount()) - { - colorizer->isColorizerRunning=false; - goto CANCEL_COLORIZING; - } - - lineIndex=colorizer->colorizedLineCount++; - TextLine& line=colorizer->element->GetLines().GetLine(lineIndex); - length=line.dataLength; - text=new wchar_t[length+2]; - colors=new vuint32_t[length+2]; - memcpy(text, line.text, sizeof(wchar_t)*length); - text[length]=L'\r'; - text[length+1]=L'\n'; - lexerState=lineIndex==0?colorizer->GetLexerStartState():colorizer->element->GetLines().GetLine(lineIndex-1).lexerFinalState; - contextState=lineIndex==0?colorizer->GetContextStartState():colorizer->element->GetLines().GetLine(lineIndex-1).contextFinalState; - } - - colorizer->ColorizeLineWithCRLF(lineIndex, text, colors, length+2, lexerState, contextState); - - SPIN_LOCK(*colorizer->elementModifyLock) - { - if(lineIndexcolorizedLineCount && lineIndexelement->GetLines().GetCount()) - { - TextLine& line=colorizer->element->GetLines().GetLine(lineIndex); - line.lexerFinalState=lexerState; - line.contextFinalState=contextState; - for(vint i=0;icolorizerRunningEvent.Leave(); } - void GuiTextBoxColorizerBase::StartColorizer() + void IGuiMenuService::MenuItemExecuted() { - if(!isColorizerRunning) + if(openingMenu) { - isColorizerRunning=true; - colorizerRunningEvent.Enter(); - ThreadPoolLite::Queue(&GuiTextBoxColorizerBase::ColorizerThreadProc, this); + openingMenu->Hide(); + } + if(GetParentMenuService()) + { + GetParentMenuService()->MenuItemExecuted(); } } - void GuiTextBoxColorizerBase::StopColorizer(bool forever) + GuiMenu* IGuiMenuService::GetOpeningMenu() { - isFinalizing=true; - colorizerRunningEvent.Enter(); - colorizerRunningEvent.Leave(); - colorizedLineCount=0; - if(!forever) + return openingMenu; + } + + void IGuiMenuService::MenuOpened(GuiMenu* menu) + { + if(openingMenu!=menu && openingMenu) { - isFinalizing=false; + openingMenu->Hide(); } + openingMenu=menu; } - void GuiTextBoxColorizerBase::StopColorizerForever() + void IGuiMenuService::MenuClosed(GuiMenu* menu) { - StopColorizer(true); - } - - GuiTextBoxColorizerBase::GuiTextBoxColorizerBase() - :element(0) - ,elementModifyLock(0) - ,colorizedLineCount(0) - ,isColorizerRunning(false) - ,isFinalizing(false) - { - } - - GuiTextBoxColorizerBase::~GuiTextBoxColorizerBase() - { - StopColorizerForever(); - } - - void GuiTextBoxColorizerBase::Attach(elements::GuiColorizedTextElement* _element, SpinLock& _elementModifyLock, compositions::GuiGraphicsComposition* _ownerComposition, vuint editVersion) - { - if(_element) + if(openingMenu==menu) { - SPIN_LOCK(_elementModifyLock) - { - element=_element; - elementModifyLock=&_elementModifyLock; - StartColorizer(); - } - } - } - - void GuiTextBoxColorizerBase::Detach() - { - if(element && elementModifyLock) - { - StopColorizer(false); - SPIN_LOCK(*elementModifyLock) - { - element=0; - elementModifyLock=0; - } - } - } - - void GuiTextBoxColorizerBase::TextEditPreview(TextEditPreviewStruct& arguments) - { - } - - void GuiTextBoxColorizerBase::TextEditNotify(const TextEditNotifyStruct& arguments) - { - if(element && elementModifyLock) - { - SPIN_LOCK(*elementModifyLock) - { - vint line - =arguments.originalStart.rowline) - { - colorizedLineCount=line; - } - StartColorizer(); - } - } - } - - void GuiTextBoxColorizerBase::TextCaretChanged(const TextCaretChangedStruct& arguments) - { - } - - void GuiTextBoxColorizerBase::TextEditFinished(vuint editVersion) - { - } - - void GuiTextBoxColorizerBase::RestartColorizer() - { - if(element && elementModifyLock) - { - SPIN_LOCK(*elementModifyLock) - { - colorizedLineCount=0; - StartColorizer(); - } + openingMenu=0; } } /*********************************************************************** -GuiTextBoxRegexColorizer +GuiMenu ***********************************************************************/ - struct GuiTextBoxRegexColorizerProcData + void GuiMenu::BeforeControlTemplateUninstalled_() { - GuiTextBoxRegexColorizer* colorizer; - vint lineIndex; - const wchar_t* text; - vuint32_t* colors; - vint contextState; - }; + } - void GuiTextBoxRegexColorizer::ColorizerProc(void* argument, vint start, vint length, vint token) + void GuiMenu::AfterControlTemplateInstalled_(bool initialize) { - GuiTextBoxRegexColorizerProcData& data=*(GuiTextBoxRegexColorizerProcData*)argument; - data.colorizer->ColorizeTokenContextSensitive(data.lineIndex, data.text, start, length, token, data.contextState); - for(vint i=0;iMenuOpened(this); } } - GuiTextBoxRegexColorizer::GuiTextBoxRegexColorizer() + void GuiMenu::OnDeactivatedAltHost() { - colors.Resize(1); + Hide(); } - GuiTextBoxRegexColorizer::~GuiTextBoxRegexColorizer() + void GuiMenu::MouseClickedOnOtherWindow(GuiWindow* window) { - StopColorizerForever(); - } - - elements::text::ColorEntry GuiTextBoxRegexColorizer::GetDefaultColor() - { - return defaultColor; - } - - collections::List& GuiTextBoxRegexColorizer::GetTokenRegexes() - { - return tokenRegexes; - } - - collections::List& GuiTextBoxRegexColorizer::GetTokenColors() - { - return tokenColors; - } - - collections::List& GuiTextBoxRegexColorizer::GetExtraTokenColors() - { - return extraTokenColors; - } - - vint GuiTextBoxRegexColorizer::GetExtraTokenIndexStart() - { - if(lexer) + GuiMenu* targetMenu=dynamic_cast(window); + if(!targetMenu) { - return tokenColors.Count(); - } - else - { - return -1; + Hide(); } } - bool GuiTextBoxRegexColorizer::SetDefaultColor(elements::text::ColorEntry value) + void GuiMenu::OnWindowClosed(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - if(lexer) + if(parentMenuService) { - return false; - } - else - { - defaultColor=value; - return true; - } - } - - vint GuiTextBoxRegexColorizer::AddToken(const WString& regex, elements::text::ColorEntry color) - { - if(lexer) - { - return -1; - } - else - { - tokenRegexes.Add(regex); - tokenColors.Add(color); - return tokenColors.Count()-1; - } - } - - vint GuiTextBoxRegexColorizer::AddExtraToken(elements::text::ColorEntry color) - { - if(lexer) - { - return -1; - } - else - { - extraTokenColors.Add(color); - return extraTokenColors.Count()-1; - } - } - - void GuiTextBoxRegexColorizer::ClearTokens() - { - tokenRegexes.Clear(); - tokenColors.Clear(); - extraTokenColors.Clear(); - lexer=0; - } - - void GuiTextBoxRegexColorizer::Setup() - { - if(lexer || tokenRegexes.Count()==0) - { - colors.Resize(1); - colors[0]=defaultColor; - } - else - { - lexer=new regex::RegexLexer(tokenRegexes); - colors.Resize(1+tokenRegexes.Count()+extraTokenColors.Count()); - colors[0]=defaultColor; - for(vint i=0;iMenuClosed(this); + GuiMenu* openingSubMenu=GetOpeningMenu(); + if(openingSubMenu) { - colors[i+1]=tokenColors[i]; + openingSubMenu->Hide(); } - for(vint i=0;iColorize()); } } - void GuiTextBoxRegexColorizer::ColorizeTokenContextSensitive(vint lineIndex, const wchar_t* text, vint start, vint length, vint& token, vint& contextState) + GuiMenu::GuiMenu(theme::ThemeName themeName, GuiControl* _owner) + :GuiPopup(themeName) + , owner(_owner) + , parentMenuService(0) + { + GetNativeWindow()->SetAlwaysPassFocusToParent(true); + UpdateMenuService(); + WindowOpened.AttachMethod(this, &GuiMenu::OnWindowOpened); + WindowClosed.AttachMethod(this, &GuiMenu::OnWindowClosed); + } + + GuiMenu::~GuiMenu() { } - vint GuiTextBoxRegexColorizer::GetLexerStartState() + void GuiMenu::UpdateMenuService() { - return lexer?colorizer->GetStartState():-1; + if(owner) + { + parentMenuService=owner->QueryTypedService(); + } } - vint GuiTextBoxRegexColorizer::GetContextStartState() + IDescriptable* GuiMenu::QueryService(const WString& identifier) + { + if(identifier==IGuiMenuService::Identifier) + { + return (IGuiMenuService*)this; + } + else + { + return GuiPopup::QueryService(identifier); + } + } + +/*********************************************************************** +GuiMenuBar +***********************************************************************/ + + IGuiMenuService* GuiMenuBar::GetParentMenuService() { return 0; } - void GuiTextBoxRegexColorizer::ColorizeLineWithCRLF(vint lineIndex, const wchar_t* text, vuint32_t* colors, vint length, vint& lexerState, vint& contextState) + IGuiMenuService::Direction GuiMenuBar::GetPreferredDirection() { - memset(colors, 0, sizeof(*colors)*length); - if(lexer) - { - GuiTextBoxRegexColorizerProcData data; - data.colorizer=this; - data.lineIndex=lineIndex; - data.text=text; - data.colors=colors; - data.contextState=contextState; - - colorizer->Reset(lexerState); - colorizer->Colorize(text, length, &GuiTextBoxRegexColorizer::ColorizerProc, &data); - - lexerState=colorizer->GetCurrentState(); - contextState=data.contextState; - } - else - { - lexerState=-1; - contextState=-1; - } + return IGuiMenuService::Horizontal; } - const GuiTextBoxRegexColorizer::ColorArray& GuiTextBoxRegexColorizer::GetColors() - { - return colors; - } - } - } -} - -/*********************************************************************** -.\CONTROLS\TEXTEDITORPACKAGE\EDITORCALLBACK\GUITEXTUNDOREDO.CPP -***********************************************************************/ - -namespace vl -{ - namespace presentation - { - namespace controls - { - using namespace elements; - using namespace elements::text; - using namespace compositions; - -/*********************************************************************** -GuiGeneralUndoRedoProcessor -***********************************************************************/ - - GuiGeneralUndoRedoProcessor::GuiGeneralUndoRedoProcessor() - :firstFutureStep(0) - ,savedStep(0) - ,performingUndoRedo(false) + bool GuiMenuBar::IsActiveState() { + return GetOpeningMenu()!=0; } - GuiGeneralUndoRedoProcessor::~GuiGeneralUndoRedoProcessor() + bool GuiMenuBar::IsSubMenuActivatedByMouseDown() { - } - - void GuiGeneralUndoRedoProcessor::PushStep(Ptr step) - { - if(!performingUndoRedo) - { - if(firstFutureStep0) - { - steps.RemoveRange(firstFutureStep, count); - } - - steps.Add(step); - firstFutureStep=steps.Count(); - UndoRedoChanged(); - ModifiedChanged(); - } - } - - bool GuiGeneralUndoRedoProcessor::CanUndo() - { - return firstFutureStep>0; - } - - bool GuiGeneralUndoRedoProcessor::CanRedo() - { - return steps.Count()>firstFutureStep; - } - - void GuiGeneralUndoRedoProcessor::ClearUndoRedo() - { - if(!performingUndoRedo) - { - steps.Clear(); - firstFutureStep=0; - savedStep=-1; - } - } - - bool GuiGeneralUndoRedoProcessor::GetModified() - { - return firstFutureStep!=savedStep; - } - - void GuiGeneralUndoRedoProcessor::NotifyModificationSaved() - { - if(!performingUndoRedo) - { - savedStep=firstFutureStep; - ModifiedChanged(); - } - } - - bool GuiGeneralUndoRedoProcessor::Undo() - { - if(!CanUndo()) return false; - performingUndoRedo=true; - firstFutureStep--; - steps[firstFutureStep]->Undo(); - performingUndoRedo=false; - UndoRedoChanged(); - ModifiedChanged(); return true; } - bool GuiGeneralUndoRedoProcessor::Redo() - { - if(!CanRedo()) return false; - performingUndoRedo=true; - firstFutureStep++; - steps[firstFutureStep-1]->Redo(); - performingUndoRedo=false; - UndoRedoChanged(); - ModifiedChanged(); - return true; - } - -/*********************************************************************** -GuiTextBoxUndoRedoProcessor::EditStep -***********************************************************************/ - - void GuiTextBoxUndoRedoProcessor::EditStep::Undo() - { - GuiTextBoxCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); - if(ci) - { - ci->Select(arguments.inputStart, arguments.inputEnd); - ci->SetSelectionText(arguments.originalText); - ci->Select(arguments.originalStart, arguments.originalEnd); - } - } - - void GuiTextBoxUndoRedoProcessor::EditStep::Redo() - { - GuiTextBoxCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); - if(ci) - { - ci->Select(arguments.originalStart, arguments.originalEnd); - ci->SetSelectionText(arguments.inputText); - ci->Select(arguments.inputStart, arguments.inputEnd); - } - } - -/*********************************************************************** -GuiTextBoxUndoRedoProcessor -***********************************************************************/ - - GuiTextBoxUndoRedoProcessor::GuiTextBoxUndoRedoProcessor() - :ownerComposition(0) - { - } - - GuiTextBoxUndoRedoProcessor::~GuiTextBoxUndoRedoProcessor() - { - } - - void GuiTextBoxUndoRedoProcessor::Attach(elements::GuiColorizedTextElement* element, SpinLock& elementModifyLock, compositions::GuiGraphicsComposition* _ownerComposition, vuint editVersion) - { - ownerComposition=_ownerComposition; - } - - void GuiTextBoxUndoRedoProcessor::Detach() - { - ClearUndoRedo(); - } - - void GuiTextBoxUndoRedoProcessor::TextEditPreview(TextEditPreviewStruct& arguments) - { - } - - void GuiTextBoxUndoRedoProcessor::TextEditNotify(const TextEditNotifyStruct& arguments) - { - Ptr step=new EditStep; - step->processor=this; - step->arguments=arguments; - PushStep(step); - } - - void GuiTextBoxUndoRedoProcessor::TextCaretChanged(const TextCaretChangedStruct& arguments) - { - } - - void GuiTextBoxUndoRedoProcessor::TextEditFinished(vuint editVersion) - { - } - -/*********************************************************************** -GuiDocumentUndoRedoProcessor::ReplaceModelStep -***********************************************************************/ - - void GuiDocumentUndoRedoProcessor::ReplaceModelStep::Undo() - { - GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); - if(ci) - { - ci->EditRun(arguments.inputStart, arguments.inputEnd, arguments.originalModel, true); - ci->SetCaret(arguments.originalStart, arguments.originalEnd); - } - } - - void GuiDocumentUndoRedoProcessor::ReplaceModelStep::Redo() - { - GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); - if(ci) - { - ci->EditRun(arguments.originalStart, arguments.originalEnd, arguments.inputModel, true); - ci->SetCaret(arguments.inputStart, arguments.inputEnd); - } - } - -/*********************************************************************** -GuiDocumentUndoRedoProcessor::RenameStyleStep -***********************************************************************/ - - void GuiDocumentUndoRedoProcessor::RenameStyleStep::Undo() - { - GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); - if(ci) - { - ci->RenameStyle(arguments.newStyleName, arguments.oldStyleName); - } - } - - void GuiDocumentUndoRedoProcessor::RenameStyleStep::Redo() - { - GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); - if(ci) - { - ci->RenameStyle(arguments.oldStyleName, arguments.newStyleName); - } - } - -/*********************************************************************** -GuiDocumentUndoRedoProcessor::SetAlignmentStep -***********************************************************************/ - - void GuiDocumentUndoRedoProcessor::SetAlignmentStep::Undo() - { - GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); - if(ci) - { - ci->SetParagraphAlignments(TextPos(arguments->start, 0), TextPos(arguments->end, 0), arguments->originalAlignments); - } - } - - void GuiDocumentUndoRedoProcessor::SetAlignmentStep::Redo() - { - GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); - if(ci) - { - ci->SetParagraphAlignments(TextPos(arguments->start, 0), TextPos(arguments->end, 0), arguments->inputAlignments); - } - } - -/*********************************************************************** -GuiDocumentUndoRedoProcessor -***********************************************************************/ - - GuiDocumentUndoRedoProcessor::GuiDocumentUndoRedoProcessor() - :element(0) - ,ownerComposition(0) - { - } - - GuiDocumentUndoRedoProcessor::~GuiDocumentUndoRedoProcessor() - { - } - - void GuiDocumentUndoRedoProcessor::Setup(elements::GuiDocumentElement* _element, compositions::GuiGraphicsComposition* _ownerComposition) - { - element=_element; - ownerComposition=_ownerComposition; - } - - void GuiDocumentUndoRedoProcessor::OnReplaceModel(const ReplaceModelStruct& arguments) - { - Ptr step=new ReplaceModelStep; - step->processor=this; - step->arguments=arguments; - PushStep(step); - } - - void GuiDocumentUndoRedoProcessor::OnRenameStyle(const RenameStyleStruct& arguments) - { - Ptr step=new RenameStyleStep; - step->processor=this; - step->arguments=arguments; - PushStep(step); - } - - void GuiDocumentUndoRedoProcessor::OnSetAlignment(Ptr arguments) - { - Ptr step=new SetAlignmentStep; - step->processor=this; - step->arguments=arguments; - PushStep(step); - } - } - } -} - -/*********************************************************************** -.\CONTROLS\TEXTEDITORPACKAGE\GUIDOCUMENTVIEWER.CPP -***********************************************************************/ - -namespace vl -{ - namespace presentation - { - namespace controls - { - using namespace collections; - using namespace elements; - using namespace compositions; - -/*********************************************************************** -GuiDocumentItem -***********************************************************************/ - - GuiDocumentItem::GuiDocumentItem(const WString& _name) - :name(_name) - { - container = new GuiBoundsComposition; - container->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - container->SetAssociatedCursor(GetCurrentController()->ResourceService()->GetSystemCursor(INativeCursor::Arrow)); - } - - GuiDocumentItem::~GuiDocumentItem() - { - if (!owned) - { - SafeDeleteComposition(container); - } - } - - compositions::GuiGraphicsComposition* GuiDocumentItem::GetContainer() - { - return container; - } - - WString GuiDocumentItem::GetName() - { - return name; - } - -/*********************************************************************** -GuiDocumentCommonInterface -***********************************************************************/ - - void GuiDocumentCommonInterface::InvokeUndoRedoChanged() - { - UndoRedoChanged.Execute(documentControl->GetNotifyEventArguments()); - } - - void GuiDocumentCommonInterface::InvokeModifiedChanged() - { - ModifiedChanged.Execute(documentControl->GetNotifyEventArguments()); - } - - void GuiDocumentCommonInterface::UpdateCaretPoint() - { - GuiGraphicsHost* host=documentComposition->GetRelatedGraphicsHost(); - if(host) - { - Rect caret=documentElement->GetCaretBounds(documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide()); - Point view=GetDocumentViewPosition(); - vint x=caret.x1-view.x; - vint y=caret.y2-view.y; - host->SetCaretPoint(Point(x, y), documentComposition); - } - } - - void GuiDocumentCommonInterface::Move(TextPos caret, bool shift, bool frontSide) - { - TextPos begin=documentElement->GetCaretBegin(); - TextPos end=documentElement->GetCaretEnd(); - - TextPos newBegin=shift?begin:caret; - TextPos newEnd=caret; - documentElement->SetCaret(newBegin, newEnd, frontSide); - documentElement->SetCaretVisible(true); - - Rect bounds=documentElement->GetCaretBounds(newEnd, frontSide); - if(bounds!=Rect()) - { - bounds.x1-=15; - bounds.y1-=15; - bounds.x2+=15; - bounds.y2+=15; - EnsureRectVisible(bounds); - } - UpdateCaretPoint(); - SelectionChanged.Execute(documentControl->GetNotifyEventArguments()); - } - - bool GuiDocumentCommonInterface::ProcessKey(vint code, bool shift, bool ctrl) - { - if(IGuiShortcutKeyItem* item=internalShortcutKeyManager->TryGetShortcut(ctrl, shift, false, code)) - { - GuiEventArgs arguments; - item->Executed.Execute(arguments); - return true; - } - - TextPos currentCaret=documentElement->GetCaretEnd(); - bool frontSide=documentElement->IsCaretEndPreferFrontSide(); - TextPos begin=documentElement->GetCaretBegin(); - TextPos end=documentElement->GetCaretEnd(); - - switch(code) - { - case VKEY_UP: - { - TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretMoveUp, frontSide); - Move(newCaret, shift, frontSide); - } - break; - case VKEY_DOWN: - { - TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretMoveDown, frontSide); - Move(newCaret, shift, frontSide); - } - break; - case VKEY_LEFT: - { - TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretMoveLeft, frontSide); - Move(newCaret, shift, frontSide); - } - break; - case VKEY_RIGHT: - { - TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretMoveRight, frontSide); - Move(newCaret, shift, frontSide); - } - break; - case VKEY_HOME: - { - TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretLineFirst, frontSide); - if(newCaret==currentCaret) - { - newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretFirst, frontSide); - } - Move(newCaret, shift, frontSide); - } - break; - case VKEY_END: - { - TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretLineLast, frontSide); - if(newCaret==currentCaret) - { - newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretLast, frontSide); - } - Move(newCaret, shift, frontSide); - } - break; - case VKEY_PRIOR: - { - } - break; - case VKEY_NEXT: - { - } - break; - case VKEY_BACK: - if(editMode==Editable) - { - if(begin==end) - { - ProcessKey(VKEY_LEFT, true, false); - } - Array text; - EditText(documentElement->GetCaretBegin(), documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide(), text); - return true; - } - break; - case VKEY_DELETE: - if(editMode==Editable) - { - if(begin==end) - { - ProcessKey(VKEY_RIGHT, true, false); - } - Array text; - EditText(documentElement->GetCaretBegin(), documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide(), text); - return true; - } - break; - case VKEY_RETURN: - if(editMode==Editable) - { - if(ctrl) - { - Array text(1); - text[0]=L"\r\n"; - EditText(documentElement->GetCaretBegin(), documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide(), text); - } - else - { - Array text(2); - EditText(documentElement->GetCaretBegin(), documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide(), text); - } - return true; - } - break; - } - return false; - } - - void GuiDocumentCommonInterface::InstallDocumentViewer( - GuiControl* _sender, - compositions::GuiGraphicsComposition* _container, - compositions::GuiGraphicsComposition* eventComposition, - compositions::GuiGraphicsComposition* focusableComposition - ) - { - documentControl=_sender; - - documentElement=GuiDocumentElement::Create(); - documentElement->SetCallback(this); - - documentComposition=new GuiBoundsComposition; - documentComposition->SetOwnedElement(documentElement); - documentComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElement); - documentComposition->SetAlignmentToParent(Margin(5, 5, 5, 5)); - _container->AddChild(documentComposition); - - documentComposition->GetEventReceiver()->mouseMove.AttachMethod(this, &GuiDocumentCommonInterface::OnMouseMove); - documentComposition->GetEventReceiver()->leftButtonDown.AttachMethod(this, &GuiDocumentCommonInterface::OnMouseDown); - documentComposition->GetEventReceiver()->leftButtonUp.AttachMethod(this, &GuiDocumentCommonInterface::OnMouseUp); - documentComposition->GetEventReceiver()->mouseLeave.AttachMethod(this, &GuiDocumentCommonInterface::OnMouseLeave); - - _sender->FontChanged.AttachMethod(this, &GuiDocumentCommonInterface::OnFontChanged); - focusableComposition->GetEventReceiver()->caretNotify.AttachMethod(this, &GuiDocumentCommonInterface::OnCaretNotify); - focusableComposition->GetEventReceiver()->gotFocus.AttachMethod(this, &GuiDocumentCommonInterface::OnGotFocus); - focusableComposition->GetEventReceiver()->lostFocus.AttachMethod(this, &GuiDocumentCommonInterface::OnLostFocus); - focusableComposition->GetEventReceiver()->keyDown.AttachMethod(this, &GuiDocumentCommonInterface::OnKeyDown); - focusableComposition->GetEventReceiver()->charInput.AttachMethod(this, &GuiDocumentCommonInterface::OnCharInput); - - undoRedoProcessor->Setup(documentElement, documentComposition); - ActiveHyperlinkChanged.SetAssociatedComposition(eventComposition); - ActiveHyperlinkExecuted.SetAssociatedComposition(eventComposition); - SelectionChanged.SetAssociatedComposition(eventComposition); - UndoRedoChanged.SetAssociatedComposition(eventComposition); - ModifiedChanged.SetAssociatedComposition(eventComposition); - - undoRedoProcessor->UndoRedoChanged.Add(this, &GuiDocumentCommonInterface::InvokeUndoRedoChanged); - undoRedoProcessor->ModifiedChanged.Add(this, &GuiDocumentCommonInterface::InvokeModifiedChanged); - SetDocument(new DocumentModel); - } - - void GuiDocumentCommonInterface::SetActiveHyperlink(Ptr package) - { - ActivateActiveHyperlink(false); - activeHyperlinks = - !package ? nullptr : - package->hyperlinks.Count() == 0 ? nullptr : - package; - ActivateActiveHyperlink(true); - ActiveHyperlinkChanged.Execute(documentControl->GetNotifyEventArguments()); - } - - void GuiDocumentCommonInterface::ActivateActiveHyperlink(bool activate) - { - if (activeHyperlinks) - { - FOREACH(Ptr, run, activeHyperlinks->hyperlinks) - { - run->styleName = activate ? run->activeStyleName : run->normalStyleName; - } - documentElement->NotifyParagraphUpdated(activeHyperlinks->row, 1, 1, false); - } - } - - void GuiDocumentCommonInterface::AddShortcutCommand(vint key, const Func& eventHandler) - { - IGuiShortcutKeyItem* item=internalShortcutKeyManager->CreateShortcut(true, false, false, key); - item->Executed.AttachLambda([=](GuiGraphicsComposition* sender, GuiEventArgs& arguments) - { - eventHandler(); - }); - } - - void GuiDocumentCommonInterface::EditTextInternal(TextPos begin, TextPos end, const Func& editor) - { - // save run before editing - if(begin>end) - { - TextPos temp=begin; - begin=end; - end=temp; - } - Ptr originalModel=documentElement->GetDocument()->CopyDocument(begin, end, true); - if(originalModel) - { - // edit - vint paragraphCount=0; - vint lastParagraphLength=0; - editor(begin, end, paragraphCount, lastParagraphLength); - - // calculate new caret - TextPos caret; - if(paragraphCount==0) - { - caret=begin; - } - else if(paragraphCount==1) - { - caret=TextPos(begin.row, begin.column+lastParagraphLength); - } - else - { - caret=TextPos(begin.row+paragraphCount-1, lastParagraphLength); - } - documentElement->SetCaret(caret, caret, true); - documentControl->TextChanged.Execute(documentControl->GetNotifyEventArguments()); - UpdateCaretPoint(); - SelectionChanged.Execute(documentControl->GetNotifyEventArguments()); - - // save run after editing - Ptr inputModel=documentElement->GetDocument()->CopyDocument(begin, caret, true); - - // submit redo-undo - GuiDocumentUndoRedoProcessor::ReplaceModelStruct arguments; - arguments.originalStart=begin; - arguments.originalEnd=end; - arguments.originalModel=originalModel; - arguments.inputStart=begin; - arguments.inputEnd=caret; - arguments.inputModel=inputModel; - undoRedoProcessor->OnReplaceModel(arguments); - } - } - - void GuiDocumentCommonInterface::EditStyleInternal(TextPos begin, TextPos end, const Func& editor) - { - // save run before editing - if(begin>end) - { - TextPos temp=begin; - begin=end; - end=temp; - } - Ptr originalModel=documentElement->GetDocument()->CopyDocument(begin, end, true); - if(originalModel) - { - // edit - editor(begin, end); - - // save run after editing - Ptr inputModel=documentElement->GetDocument()->CopyDocument(begin, end, true); - - // submit redo-undo - GuiDocumentUndoRedoProcessor::ReplaceModelStruct arguments; - arguments.originalStart=begin; - arguments.originalEnd=end; - arguments.originalModel=originalModel; - arguments.inputStart=begin; - arguments.inputEnd=end; - arguments.inputModel=inputModel; - undoRedoProcessor->OnReplaceModel(arguments); - } - } - - void GuiDocumentCommonInterface::MergeBaselineAndDefaultFont(Ptr document) - { - document->MergeDefaultFont(documentControl->GetFont()); - if (baselineDocument) - { - document->MergeBaselineStyles(baselineDocument); - } - } - - void GuiDocumentCommonInterface::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - auto document = documentElement->GetDocument(); - MergeBaselineAndDefaultFont(document); - documentElement->SetDocument(document); - } - - void GuiDocumentCommonInterface::OnCaretNotify(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if(documentControl->GetVisuallyEnabled()) - { - if(editMode!=ViewOnly) - { - documentElement->SetCaretVisible(!documentElement->GetCaretVisible()); - } - } - } - - void GuiDocumentCommonInterface::OnGotFocus(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if(documentControl->GetVisuallyEnabled()) - { - if(editMode!=ViewOnly) - { - documentElement->SetCaretVisible(true); - UpdateCaretPoint(); - } - } - } - - void GuiDocumentCommonInterface::OnLostFocus(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if(documentControl->GetVisuallyEnabled()) - { - documentElement->SetCaretVisible(false); - } - } - - void GuiDocumentCommonInterface::OnKeyDown(compositions::GuiGraphicsComposition* sender, compositions::GuiKeyEventArgs& arguments) - { - if(documentControl->GetVisuallyEnabled()) - { - if(editMode!=ViewOnly) - { - if(ProcessKey(arguments.code, arguments.shift, arguments.ctrl)) - { - arguments.handled=true; - } - } - } - } - - void GuiDocumentCommonInterface::OnCharInput(compositions::GuiGraphicsComposition* sender, compositions::GuiCharEventArgs& arguments) - { - if(documentControl->GetVisuallyEnabled()) - { - if(editMode==Editable && arguments.code!=VKEY_ESCAPE && arguments.code!=VKEY_BACK && arguments.code!=VKEY_RETURN && !arguments.ctrl) - { - Array text(1); - text[0]=WString(arguments.code); - EditText(documentElement->GetCaretBegin(), documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide(), text); - } - } - } - - void GuiDocumentCommonInterface::OnMouseMove(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) - { - if(documentControl->GetVisuallyEnabled()) - { - switch(editMode) - { - case ViewOnly: - { - auto package = documentElement->GetHyperlinkFromPoint({ arguments.x, arguments.y }); - bool handCursor = false; - - if(dragging) - { - if(activeHyperlinks) - { - if (package && CompareEnumerable(activeHyperlinks->hyperlinks, package->hyperlinks) == 0) - { - ActivateActiveHyperlink(true); - handCursor = true; - } - else - { - ActivateActiveHyperlink(false); - } - } - } - else - { - SetActiveHyperlink(package); - handCursor = activeHyperlinks; - } - - if(handCursor) - { - auto cursor = GetCurrentController()->ResourceService()->GetSystemCursor(INativeCursor::Hand); - documentComposition->SetAssociatedCursor(cursor); - } - else - { - documentComposition->SetAssociatedCursor(nullptr); - } - } - break; - case Selectable: - case Editable: - if(dragging) - { - TextPos caret=documentElement->CalculateCaretFromPoint(Point(arguments.x, arguments.y)); - TextPos oldCaret=documentElement->GetCaretBegin(); - Move(caret, true, (oldCaret==caret?documentElement->IsCaretEndPreferFrontSide():caretGetVisuallyEnabled()) - { - documentControl->SetFocus(); - switch(editMode) - { - case ViewOnly: - SetActiveHyperlink(documentElement->GetHyperlinkFromPoint({ arguments.x, arguments.y })); - break; - case Selectable: - case Editable: - { - TextPos caret=documentElement->CalculateCaretFromPoint(Point(arguments.x, arguments.y)); - TextPos oldCaret=documentElement->GetCaretEnd(); - if(caret!=oldCaret) - { - Move(caret, arguments.shift, caretGetVisuallyEnabled()) - { - dragging=false; - switch(editMode) - { - case ViewOnly: - { - auto package = documentElement->GetHyperlinkFromPoint({ arguments.x, arguments.y }); - if(activeHyperlinks) - { - if (package && CompareEnumerable(activeHyperlinks->hyperlinks, package->hyperlinks) == 0) - { - ActiveHyperlinkExecuted.Execute(documentControl->GetNotifyEventArguments()); - } - else - { - SetActiveHyperlink(nullptr); - } - } - } - break; - default:; - } - } - } - - void GuiDocumentCommonInterface::OnMouseLeave(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - SetActiveHyperlink(0); - } - - Point GuiDocumentCommonInterface::GetDocumentViewPosition() - { - return Point(0, 0); - } - - void GuiDocumentCommonInterface::EnsureRectVisible(Rect bounds) - { - } - - //================ callback - - void GuiDocumentCommonInterface::OnStartRender() - { - FOREACH(Ptr, item, documentItems.Values()) - { - item->visible = false; - } - } - - void GuiDocumentCommonInterface::OnFinishRender() - { - FOREACH(Ptr, item, documentItems.Values()) - { - if (item->container->GetVisible() != item->visible) - { - item->container->SetVisible(item->visible); - } - } - } - - Size GuiDocumentCommonInterface::OnRenderEmbeddedObject(const WString& name, const Rect& location) - { - vint index = documentItems.Keys().IndexOf(name); - if (index != -1) - { - auto item = documentItems.Values()[index]; - auto size = item->container->GetBounds().GetSize(); - item->container->SetBounds(Rect(location.LeftTop(), Size(0, 0))); - item->visible = true; - return size; - } - return Size(); - } - - //================ basic - - GuiDocumentCommonInterface::GuiDocumentCommonInterface() - { - undoRedoProcessor=new GuiDocumentUndoRedoProcessor; - - internalShortcutKeyManager=new GuiShortcutKeyManager; - AddShortcutCommand('Z', Func(this, &GuiDocumentCommonInterface::Undo)); - AddShortcutCommand('Y', Func(this, &GuiDocumentCommonInterface::Redo)); - AddShortcutCommand('A', Func(this, &GuiDocumentCommonInterface::SelectAll)); - AddShortcutCommand('X', Func(this, &GuiDocumentCommonInterface::Cut)); - AddShortcutCommand('C', Func(this, &GuiDocumentCommonInterface::Copy)); - AddShortcutCommand('V', Func(this, &GuiDocumentCommonInterface::Paste)); - } - - GuiDocumentCommonInterface::~GuiDocumentCommonInterface() - { - } - - Ptr GuiDocumentCommonInterface::GetDocument() - { - return documentElement->GetDocument(); - } - - void GuiDocumentCommonInterface::SetDocument(Ptr value) - { - SetActiveHyperlink(0); - ClearUndoRedo(); - NotifyModificationSaved(); - - if (value) - { - if (value->paragraphs.Count() == 0) - { - value->paragraphs.Add(new DocumentParagraphRun); - } - MergeBaselineAndDefaultFont(value); - } - - documentElement->SetDocument(value); - } - - //================ document items - - bool GuiDocumentCommonInterface::AddDocumentItem(Ptr value) - { - if (documentItems.Keys().Contains(value->GetName())) - { - return false; - } - documentItems.Add(value->GetName(), value); - documentComposition->AddChild(value->container); - value->visible = false; - value->owned = true; - value->container->SetVisible(false); - return true; - } - - bool GuiDocumentCommonInterface::RemoveDocumentItem(Ptr value) - { - vint index = documentItems.Keys().IndexOf(value->GetName()); - if (index == -1) - { - return false; - } - if (documentItems.Values()[index] != value) - { - return false; - } - value->owned = false; - documentComposition->RemoveChild(value->container); - documentItems.Remove(value->GetName()); - return true; - } - - const GuiDocumentCommonInterface::DocumentItemMap& GuiDocumentCommonInterface::GetDocumentItems() - { - return documentItems; - } - - //================ caret operations - - TextPos GuiDocumentCommonInterface::GetCaretBegin() - { - return documentElement->GetCaretBegin(); - } - - TextPos GuiDocumentCommonInterface::GetCaretEnd() - { - return documentElement->GetCaretEnd(); - } - - void GuiDocumentCommonInterface::SetCaret(TextPos begin, TextPos end) - { - documentElement->SetCaret(begin, end, end>=begin); - UpdateCaretPoint(); - SelectionChanged.Execute(documentControl->GetNotifyEventArguments()); - } - - TextPos GuiDocumentCommonInterface::CalculateCaretFromPoint(Point point) - { - return documentElement->CalculateCaretFromPoint(point); - } - - Rect GuiDocumentCommonInterface::GetCaretBounds(TextPos caret, bool frontSide) - { - return documentElement->GetCaretBounds(caret, frontSide); - } - - //================ editing operations - - void GuiDocumentCommonInterface::NotifyParagraphUpdated(vint index, vint oldCount, vint newCount, bool updatedText) - { - documentElement->NotifyParagraphUpdated(index, oldCount, newCount, updatedText); - } - - void GuiDocumentCommonInterface::EditRun(TextPos begin, TextPos end, Ptr model, bool copy) - { - EditTextInternal(begin, end, [=](TextPos begin, TextPos end, vint& paragraphCount, vint& lastParagraphLength) - { - documentElement->EditRun(begin, end, model, copy); - paragraphCount=model->paragraphs.Count(); - lastParagraphLength=paragraphCount==0?0:model->paragraphs[paragraphCount-1]->GetText(false).Length(); - }); - } - - void GuiDocumentCommonInterface::EditText(TextPos begin, TextPos end, bool frontSide, const collections::Array& text) - { - EditTextInternal(begin, end, [=, &text](TextPos begin, TextPos end, vint& paragraphCount, vint& lastParagraphLength) - { - documentElement->EditText(begin, end, frontSide, text); - paragraphCount=text.Count(); - lastParagraphLength=paragraphCount==0?0:text[paragraphCount-1].Length(); - }); - } - - void GuiDocumentCommonInterface::EditStyle(TextPos begin, TextPos end, Ptr style) - { - EditStyleInternal(begin, end, [=](TextPos begin, TextPos end) - { - documentElement->EditStyle(begin, end, style); - }); - } - - void GuiDocumentCommonInterface::EditImage(TextPos begin, TextPos end, Ptr image) - { - EditTextInternal(begin, end, [=](TextPos begin, TextPos end, vint& paragraphCount, vint& lastParagraphLength) - { - documentElement->EditImage(begin, end, image); - paragraphCount=1; - lastParagraphLength=wcslen(DocumentImageRun::RepresentationText); - }); - } - - void GuiDocumentCommonInterface::EditHyperlink(vint paragraphIndex, vint begin, vint end, const WString& reference, const WString& normalStyleName, const WString& activeStyleName) - { - EditStyleInternal(TextPos(paragraphIndex, begin), TextPos(paragraphIndex, end), [=](TextPos begin, TextPos end) - { - documentElement->EditHyperlink(begin.row, begin.column, end.column, reference, normalStyleName, activeStyleName); - }); - } - - void GuiDocumentCommonInterface::RemoveHyperlink(vint paragraphIndex, vint begin, vint end) - { - EditStyleInternal(TextPos(paragraphIndex, begin), TextPos(paragraphIndex, end), [=](TextPos begin, TextPos end) - { - documentElement->RemoveHyperlink(begin.row, begin.column, end.column); - }); - } - - void GuiDocumentCommonInterface::EditStyleName(TextPos begin, TextPos end, const WString& styleName) - { - EditStyleInternal(begin, end, [=](TextPos begin, TextPos end) - { - documentElement->EditStyleName(begin, end, styleName); - }); - } - - void GuiDocumentCommonInterface::RemoveStyleName(TextPos begin, TextPos end) - { - EditStyleInternal(begin, end, [=](TextPos begin, TextPos end) - { - documentElement->RemoveStyleName(begin, end); - }); - } - - void GuiDocumentCommonInterface::RenameStyle(const WString& oldStyleName, const WString& newStyleName) - { - documentElement->RenameStyle(oldStyleName, newStyleName); - - // submit redo-undo - GuiDocumentUndoRedoProcessor::RenameStyleStruct arguments; - arguments.oldStyleName=oldStyleName; - arguments.newStyleName=newStyleName; - undoRedoProcessor->OnRenameStyle(arguments); - } - - void GuiDocumentCommonInterface::ClearStyle(TextPos begin, TextPos end) - { - EditStyleInternal(begin, end, [=](TextPos begin, TextPos end) - { - documentElement->ClearStyle(begin, end); - }); - } - - Ptr GuiDocumentCommonInterface::SummarizeStyle(TextPos begin, TextPos end) - { - if (begin>end) - { - TextPos temp = begin; - begin = end; - end = temp; - } - return documentElement->SummarizeStyle(begin, end); - } - - void GuiDocumentCommonInterface::SetParagraphAlignments(TextPos begin, TextPos end, const collections::Array>& alignments) - { - vint first = begin.row; - vint last = end.row; - if (first > last) - { - vint temp = first; - first = last; - last = temp; - } - - Ptr document = documentElement->GetDocument(); - if (0 <= first && first < document->paragraphs.Count() && 0 <= last && last < document->paragraphs.Count() && last - first + 1 == alignments.Count()) - { - Ptr arguments = new GuiDocumentUndoRedoProcessor::SetAlignmentStruct; - arguments->start = first; - arguments->end = last; - arguments->originalAlignments.Resize(alignments.Count()); - arguments->inputAlignments.Resize(alignments.Count()); - for (vint i = first; i <= last; i++) - { - arguments->originalAlignments[i - first] = document->paragraphs[i]->alignment; - arguments->inputAlignments[i - first] = alignments[i - first]; - } - documentElement->SetParagraphAlignment(begin, end, alignments); - undoRedoProcessor->OnSetAlignment(arguments); - } - } - - void GuiDocumentCommonInterface::SetParagraphAlignment(TextPos begin, TextPos end, Nullable alignment) - { -#if defined VCZH_GCC && defined VCZH_64 -#define abs labs -#endif - Array> alignments(abs(begin.row - end.row) + 1); -#if defined VCZH_GCC && defined VCZH_64 -#undef abs -#endif - for (vint i = 0; i < alignments.Count(); i++) - { - alignments[i] = alignment; - } - SetParagraphAlignments(begin, end, alignments); - } - - Nullable GuiDocumentCommonInterface::SummarizeParagraphAlignment(TextPos begin, TextPos end) - { - if (begin>end) - { - TextPos temp = begin; - begin = end; - end = temp; - } - return documentElement->SummarizeParagraphAlignment(begin, end); - } - - //================ editing control - - WString GuiDocumentCommonInterface::GetActiveHyperlinkReference() - { - return activeHyperlinks ? activeHyperlinks->hyperlinks[0]->reference : L""; - } - - GuiDocumentCommonInterface::EditMode GuiDocumentCommonInterface::GetEditMode() - { - return editMode; - } - - void GuiDocumentCommonInterface::SetEditMode(EditMode value) - { - if(activeHyperlinks) - { - SetActiveHyperlink(nullptr); - } - - editMode=value; - if(editMode==ViewOnly) - { - documentComposition->SetAssociatedCursor(0); - } - else - { - INativeCursor* cursor=GetCurrentController()->ResourceService()->GetSystemCursor(INativeCursor::IBeam); - documentComposition->SetAssociatedCursor(cursor); - } - } - - //================ selection operations - - void GuiDocumentCommonInterface::SelectAll() - { - vint lastIndex=documentElement->GetDocument()->paragraphs.Count()-1; - Ptr lastParagraph=documentElement->GetDocument()->paragraphs[lastIndex]; - - TextPos begin(0, 0); - TextPos end(lastIndex, lastParagraph->GetText(false).Length()); - SetCaret(begin, end); - } - - WString GuiDocumentCommonInterface::GetSelectionText() - { - TextPos begin=documentElement->GetCaretBegin(); - TextPos end=documentElement->GetCaretEnd(); - if(begin>end) - { - TextPos temp=begin; - begin=end; - end=temp; - } - - Ptr model=documentElement->GetDocument()->CopyDocument(begin, end, false); - return model->GetText(true); - } - - void GuiDocumentCommonInterface::SetSelectionText(const WString& value) - { - List paragraphs; - { - stream::StringReader reader(value); - WString paragraph; - bool empty=true; - - while(!reader.IsEnd()) - { - WString line=reader.ReadLine(); - if(empty) - { - paragraph+=line; - empty=false; - } - else if(line!=L"") - { - paragraph+=L"\r\n"+line; - } - else - { - paragraphs.Add(paragraph); - paragraph=L""; - empty=true; - } - } - - if(!empty) - { - paragraphs.Add(paragraph); - } - } - - TextPos begin=documentElement->GetCaretBegin(); - TextPos end=documentElement->GetCaretEnd(); - if(begin>end) - { - TextPos temp=begin; - begin=end; - end=temp; - } - - Array text; - CopyFrom(text, paragraphs); - EditText(begin, end, documentElement->IsCaretEndPreferFrontSide(), text); - } - - Ptr GuiDocumentCommonInterface::GetSelectionModel() - { - TextPos begin=documentElement->GetCaretBegin(); - TextPos end=documentElement->GetCaretEnd(); - if(begin>end) - { - TextPos temp=begin; - begin=end; - end=temp; - } - - Ptr model=documentElement->GetDocument()->CopyDocument(begin, end, true); - return model; - } - - void GuiDocumentCommonInterface::SetSelectionModel(Ptr value) - { - TextPos begin=documentElement->GetCaretBegin(); - TextPos end=documentElement->GetCaretEnd(); - if(begin>end) - { - TextPos temp=begin; - begin=end; - end=temp; - } - - EditRun(begin, end, value, true); - } - - //================ clipboard operations - - bool GuiDocumentCommonInterface::CanCut() - { - return editMode==Editable && documentElement->GetCaretBegin()!=documentElement->GetCaretEnd(); - } - - bool GuiDocumentCommonInterface::CanCopy() - { - return documentElement->GetCaretBegin()!=documentElement->GetCaretEnd(); - } - - bool GuiDocumentCommonInterface::CanPaste() - { - return editMode==Editable && GetCurrentController()->ClipboardService()->ContainsText(); - } - - bool GuiDocumentCommonInterface::Cut() - { - if(CanCut()) - { - GetCurrentController()->ClipboardService()->SetText(GetSelectionText()); - SetSelectionText(L""); - return true; - } - else - { - return false; - } - } - - bool GuiDocumentCommonInterface::Copy() - { - if(CanCopy()) - { - GetCurrentController()->ClipboardService()->SetText(GetSelectionText()); - return true; - } - else - { - return false; - } - } - - bool GuiDocumentCommonInterface::Paste() - { - if(CanPaste()) - { - SetSelectionText(GetCurrentController()->ClipboardService()->GetText()); - return true; - } - else - { - return false; - } - } - - //================ undo redo control - - bool GuiDocumentCommonInterface::CanUndo() - { - return editMode==Editable && undoRedoProcessor->CanUndo(); - } - - bool GuiDocumentCommonInterface::CanRedo() - { - return editMode==Editable && undoRedoProcessor->CanRedo(); - } - - void GuiDocumentCommonInterface::ClearUndoRedo() - { - undoRedoProcessor->ClearUndoRedo(); - } - - bool GuiDocumentCommonInterface::GetModified() - { - return undoRedoProcessor->GetModified(); - } - - void GuiDocumentCommonInterface::NotifyModificationSaved() - { - undoRedoProcessor->NotifyModificationSaved(); - } - - bool GuiDocumentCommonInterface::Undo() - { - if(CanUndo()) - { - return undoRedoProcessor->Undo(); - } - else - { - return false; - } - } - - bool GuiDocumentCommonInterface::Redo() - { - if(CanRedo()) - { - return undoRedoProcessor->Redo(); - } - else - { - return false; - } - } - -/*********************************************************************** -GuiDocumentViewer -***********************************************************************/ - - void GuiDocumentViewer::BeforeControlTemplateUninstalled_() - { - } - - void GuiDocumentViewer::AfterControlTemplateInstalled_(bool initialize) - { - auto ct = GetControlTemplateObject(); - baselineDocument = ct->GetBaselineDocument(); - if (documentElement) - { - documentElement->SetCaretColor(ct->GetCaretColor()); - SetDocument(GetDocument()); - } - } - - Point GuiDocumentViewer::GetDocumentViewPosition() - { - return GetViewBounds().LeftTop(); - } - - void GuiDocumentViewer::EnsureRectVisible(Rect bounds) - { - Rect viewBounds=GetViewBounds(); - vint offset=0; - if(bounds.y1viewBounds.y2) - { - offset=bounds.y2-viewBounds.y2; - } - - GetVerticalScroll()->SetPosition(viewBounds.y1+offset); - } - - GuiDocumentViewer::GuiDocumentViewer(theme::ThemeName themeName) - :GuiScrollContainer(themeName) - { - SetExtendToFullWidth(true); - SetHorizontalAlwaysVisible(false); - SetFocusableComposition(boundsComposition); - InstallDocumentViewer(this, containerComposition, boundsComposition, focusableComposition); - } - - GuiDocumentViewer::~GuiDocumentViewer() - { - } - - const WString& GuiDocumentViewer::GetText() - { - text=documentElement->GetDocument()->GetText(true); - return text; - } - - void GuiDocumentViewer::SetText(const WString& value) - { - SelectAll(); - SetSelectionText(value); - } - -/*********************************************************************** -GuiDocumentLabel -***********************************************************************/ - - void GuiDocumentLabel::BeforeControlTemplateUninstalled_() - { - } - - void GuiDocumentLabel::AfterControlTemplateInstalled_(bool initialize) - { - auto ct = GetControlTemplateObject(); - baselineDocument = ct->GetBaselineDocument(); - if (documentElement) - { - documentElement->SetCaretColor(ct->GetCaretColor()); - SetDocument(GetDocument()); - } - } - - GuiDocumentLabel::GuiDocumentLabel(theme::ThemeName themeName) + GuiMenuBar::GuiMenuBar(theme::ThemeName themeName) :GuiControl(themeName) { - SetFocusableComposition(boundsComposition); - InstallDocumentViewer(this, containerComposition, boundsComposition, focusableComposition); } - GuiDocumentLabel::~GuiDocumentLabel() + GuiMenuBar::~GuiMenuBar() { } - const WString& GuiDocumentLabel::GetText() + IDescriptable* GuiMenuBar::QueryService(const WString& identifier) { - text=documentElement->GetDocument()->GetText(true); - return text; + if(identifier==IGuiMenuService::Identifier) + { + return (IGuiMenuService*)this; + } + else + { + return GuiControl::QueryService(identifier); + } } - void GuiDocumentLabel::SetText(const WString& value) - { - SelectAll(); - SetSelectionText(value); - } - } - } -} - - /*********************************************************************** -.\CONTROLS\TEXTEDITORPACKAGE\GUITEXTCOMMONINTERFACE.CPP +GuiMenuButton ***********************************************************************/ -namespace vl -{ - namespace presentation - { - namespace controls - { - using namespace elements; - using namespace elements::text; - using namespace compositions; - -/*********************************************************************** -GuiTextBoxCommonInterface::DefaultCallback -***********************************************************************/ - - GuiTextBoxCommonInterface::DefaultCallback::DefaultCallback(elements::GuiColorizedTextElement* _textElement, compositions::GuiGraphicsComposition* _textComposition) - :textElement(_textElement) - ,textComposition(_textComposition) + void GuiMenuButton::BeforeControlTemplateUninstalled_() { + auto host = GetSubMenuHost(); + host->Clicked.Detach(hostClickedHandler); + host->GetBoundsComposition()->GetEventReceiver()->mouseEnter.Detach(hostMouseEnterHandler); + + hostClickedHandler = nullptr; + hostMouseEnterHandler = nullptr; } - GuiTextBoxCommonInterface::DefaultCallback::~DefaultCallback() + void GuiMenuButton::AfterControlTemplateInstalled_(bool initialize) { + auto ct = GetControlTemplateObject(); + auto host = GetSubMenuHost(); + + ct->SetSubMenuOpening(GetSubMenuOpening()); + ct->SetImage(image); + ct->SetShortcutText(shortcutText); + ct->SetSubMenuExisting(subMenu != nullptr); + + hostClickedHandler = host->Clicked.AttachMethod(this, &GuiMenuButton::OnClicked); + hostMouseEnterHandler = host->GetBoundsComposition()->GetEventReceiver()->mouseEnter.AttachMethod(this, &GuiMenuButton::OnMouseEnter); } - TextPos GuiTextBoxCommonInterface::DefaultCallback::GetLeftWord(TextPos pos) + GuiButton* GuiMenuButton::GetSubMenuHost() { - return pos; + GuiButton* button = GetControlTemplateObject()->GetSubMenuHost(); + return button ? button : this; } - TextPos GuiTextBoxCommonInterface::DefaultCallback::GetRightWord(TextPos pos) + void GuiMenuButton::OpenSubMenuInternal() { - return pos; + if(!GetSubMenuOpening()) + { + if(ownerMenuService) + { + GuiMenu* openingSiblingMenu=ownerMenuService->GetOpeningMenu(); + if(openingSiblingMenu) + { + openingSiblingMenu->Hide(); + } + } + SetSubMenuOpening(true); + } } - void GuiTextBoxCommonInterface::DefaultCallback::GetWord(TextPos pos, TextPos& begin, TextPos& end) + void GuiMenuButton::OnParentLineChanged() { - begin=pos; - end=pos; + GuiButton::OnParentLineChanged(); + ownerMenuService=QueryTypedService(); + if(ownerMenuService) + { + SetClickOnMouseUp(!ownerMenuService->IsSubMenuActivatedByMouseDown()); + } + if(subMenu) + { + subMenu->UpdateMenuService(); + } } - vint GuiTextBoxCommonInterface::DefaultCallback::GetPageRows() - { - return textComposition->GetBounds().Height()/textElement->GetLines().GetRowHeight(); - } - - bool GuiTextBoxCommonInterface::DefaultCallback::BeforeModify(TextPos start, TextPos end, const WString& originalText, WString& inputText) + bool GuiMenuButton::IsAltAvailable() { return true; } -/*********************************************************************** -GuiTextBoxCommonInterface -***********************************************************************/ - - void GuiTextBoxCommonInterface::InvokeUndoRedoChanged() + compositions::IGuiAltActionHost* GuiMenuButton::GetActivatingAltHost() { - UndoRedoChanged.Execute(textControl->GetNotifyEventArguments()); - } - - void GuiTextBoxCommonInterface::InvokeModifiedChanged() - { - ModifiedChanged.Execute(textControl->GetNotifyEventArguments()); - } - - void GuiTextBoxCommonInterface::UpdateCaretPoint() - { - GuiGraphicsHost* host=textComposition->GetRelatedGraphicsHost(); - if(host) + if (subMenu) { - Rect caret=textElement->GetLines().GetRectFromTextPos(textElement->GetCaretEnd()); - Point view=textElement->GetViewPosition(); - vint x=caret.x1-view.x; - vint y=caret.y2-view.y; - host->SetCaretPoint(Point(x, y), textComposition); + return subMenu->QueryTypedService(); } + return 0; } - void GuiTextBoxCommonInterface::Move(TextPos pos, bool shift) + void GuiMenuButton::OnSubMenuWindowOpened(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - TextPos oldBegin=textElement->GetCaretBegin(); - TextPos oldEnd=textElement->GetCaretEnd(); - - pos=textElement->GetLines().Normalize(pos); - if(!shift) - { - textElement->SetCaretBegin(pos); - } - textElement->SetCaretEnd(pos); - if(textControl) - { - GuiGraphicsHost* host=textComposition->GetRelatedGraphicsHost(); - if(host) - { - if(host->GetFocusedComposition()==textControl->GetFocusableComposition()) - { - textElement->SetCaretVisible(true); - } - } - } - - Rect bounds=textElement->GetLines().GetRectFromTextPos(pos); - Rect view=Rect(textElement->GetViewPosition(), textComposition->GetBounds().GetSize()); - Point viewPoint=view.LeftTop(); - - if(view.x2>view.x1 && view.y2>view.y1) - { - if(bounds.x1view.x2) - { - viewPoint.x=bounds.x2-view.Width(); - } - if(bounds.y1view.y2) - { - viewPoint.y=bounds.y2-view.Height(); - } - } - - callback->ScrollToView(viewPoint); - UpdateCaretPoint(); - - TextPos newBegin=textElement->GetCaretBegin(); - TextPos newEnd=textElement->GetCaretEnd(); - if(oldBegin!=newBegin || oldEnd!=newEnd) - { - ICommonTextEditCallback::TextCaretChangedStruct arguments; - arguments.oldBegin=oldBegin; - arguments.oldEnd=oldEnd; - arguments.newBegin=newBegin; - arguments.newEnd=newEnd; - arguments.editVersion=editVersion; - for(vint i=0;iTextCaretChanged(arguments); - } - SelectionChanged.Execute(textControl->GetNotifyEventArguments()); - } - } - - void GuiTextBoxCommonInterface::Modify(TextPos start, TextPos end, const WString& input, bool asKeyInput) - { - if(start>end) - { - TextPos temp=start; - start=end; - end=temp; - } - TextPos originalStart=start; - TextPos originalEnd=end; - WString originalText=textElement->GetLines().GetText(start, end); - WString inputText=input; - if(callback->BeforeModify(start, end, originalText, inputText)) - { - { - ICommonTextEditCallback::TextEditPreviewStruct arguments; - arguments.originalStart=originalStart; - arguments.originalEnd=originalEnd; - arguments.originalText=originalText; - arguments.inputText=inputText; - arguments.editVersion=editVersion; - arguments.keyInput=asKeyInput; - for(vint i=0;iTextEditPreview(arguments); - } - - inputText=arguments.inputText; - if(originalStart!=arguments.originalStart || originalEnd!=arguments.originalEnd) - { - originalStart=arguments.originalStart; - originalEnd=arguments.originalEnd; - originalText=textElement->GetLines().GetText(originalStart, originalEnd); - start=originalStart; - end=originalEnd; - } - } - - SPIN_LOCK(elementModifyLock) - { - end=textElement->GetLines().Modify(start, end, inputText); - } - callback->AfterModify(originalStart, originalEnd, originalText, start, end, inputText); - - editVersion++; - { - ICommonTextEditCallback::TextEditNotifyStruct arguments; - arguments.originalStart=originalStart; - arguments.originalEnd=originalEnd; - arguments.originalText=originalText; - arguments.inputStart=start; - arguments.inputEnd=end; - arguments.inputText=inputText; - arguments.editVersion=editVersion; - arguments.keyInput=asKeyInput; - for(vint i=0;iTextEditNotify(arguments); - } - } - - Move(end, false); - - for(vint i=0;iTextEditFinished(editVersion); - } - - textControl->TextChanged.Execute(textControl->GetNotifyEventArguments()); - } - } - - bool GuiTextBoxCommonInterface::ProcessKey(vint code, bool shift, bool ctrl) - { - if(IGuiShortcutKeyItem* item=internalShortcutKeyManager->TryGetShortcut(ctrl, shift, false, code)) - { - GuiEventArgs arguments; - item->Executed.Execute(arguments); - return true; - } - - TextPos begin=textElement->GetCaretBegin(); - TextPos end=textElement->GetCaretEnd(); - switch(code) - { - case VKEY_ESCAPE: - if(autoComplete && autoComplete->IsListOpening() && !shift && !ctrl) - { - autoComplete->CloseList(); - } - return true; - case VKEY_RETURN: - if(autoComplete && autoComplete->IsListOpening() && !shift && !ctrl) - { - if(autoComplete->ApplySelectedListItem()) - { - preventEnterDueToAutoComplete=true; - return true; - } - } - break; - case VKEY_UP: - if(autoComplete && autoComplete->IsListOpening() && !shift && !ctrl) - { - autoComplete->SelectPreviousListItem(); - } - else - { - end.row--; - Move(end, shift); - } - return true; - case VKEY_DOWN: - if(autoComplete && autoComplete->IsListOpening() && !shift && !ctrl) - { - autoComplete->SelectNextListItem(); - } - else - { - end.row++; - Move(end, shift); - } - return true; - case VKEY_LEFT: - { - if(ctrl) - { - Move(callback->GetLeftWord(end), shift); - } - else - { - if(end.column==0) - { - if(end.row>0) - { - end.row--; - end=textElement->GetLines().Normalize(end); - end.column=textElement->GetLines().GetLine(end.row).dataLength; - } - } - else - { - end.column--; - } - Move(end, shift); - } - } - return true; - case VKEY_RIGHT: - { - if(ctrl) - { - Move(callback->GetRightWord(end), shift); - } - else - { - if(end.column==textElement->GetLines().GetLine(end.row).dataLength) - { - if(end.rowGetLines().GetCount()-1) - { - end.row++; - end.column=0; - } - } - else - { - end.column++; - } - Move(end, shift); - } - } - return true; - case VKEY_HOME: - { - if(ctrl) - { - Move(TextPos(0, 0), shift); - } - else - { - end.column=0; - Move(end, shift); - } - } - return true; - case VKEY_END: - { - if(ctrl) - { - end.row=textElement->GetLines().GetCount()-1; - } - end.column=textElement->GetLines().GetLine(end.row).dataLength; - Move(end, shift); - } - return true; - case VKEY_PRIOR: - { - end.row-=callback->GetPageRows(); - Move(end, shift); - } - return true; - case VKEY_NEXT: - { - end.row+=callback->GetPageRows(); - Move(end, shift); - } - return true; - case VKEY_BACK: - if(!readonly) - { - if(ctrl && !shift) - { - ProcessKey(VKEY_LEFT, true, true); - ProcessKey(VKEY_BACK, false, false); - } - else if(!ctrl && shift) - { - ProcessKey(VKEY_UP, true, false); - ProcessKey(VKEY_BACK, false, false); - } - else - { - if(begin==end) - { - ProcessKey(VKEY_LEFT, true, false); - } - SetSelectionTextAsKeyInput(L""); - } - return true; - } - break; - case VKEY_DELETE: - if(!readonly) - { - if(ctrl && !shift) - { - ProcessKey(VKEY_RIGHT, true, true); - ProcessKey(VKEY_DELETE, false, false); - } - else if(!ctrl && shift) - { - ProcessKey(VKEY_DOWN, true, false); - ProcessKey(VKEY_DELETE, false, false); - } - else - { - if(begin==end) - { - ProcessKey(VKEY_RIGHT, true, false); - } - SetSelectionTextAsKeyInput(L""); - } - return true; - } - break; - } - return false; - } - - void GuiTextBoxCommonInterface::OnGotFocus(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - textElement->SetFocused(true); - textElement->SetCaretVisible(true); - UpdateCaretPoint(); - } - - void GuiTextBoxCommonInterface::OnLostFocus(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - textElement->SetFocused(false); - textElement->SetCaretVisible(false); - } - - void GuiTextBoxCommonInterface::OnCaretNotify(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - textElement->SetCaretVisible(!textElement->GetCaretVisible()); - } - - void GuiTextBoxCommonInterface::OnLeftButtonDown(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) - { - if(textControl->GetVisuallyEnabled() && arguments.compositionSource==arguments.eventSource) - { - dragging=true; - TextPos pos=GetNearestTextPos(Point(arguments.x, arguments.y)); - Move(pos, arguments.shift); - } - } - - void GuiTextBoxCommonInterface::OnLeftButtonUp(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) - { - if(textControl->GetVisuallyEnabled() && arguments.compositionSource==arguments.eventSource) - { - dragging=false; - } - } - - void GuiTextBoxCommonInterface::OnMouseMove(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) - { - if(textControl->GetVisuallyEnabled() && arguments.compositionSource==arguments.eventSource) - { - if(dragging) - { - TextPos pos=GetNearestTextPos(Point(arguments.x, arguments.y)); - Move(pos, true); - } - } - } - - void GuiTextBoxCommonInterface::OnKeyDown(compositions::GuiGraphicsComposition* sender, compositions::GuiKeyEventArgs& arguments) - { - if(textControl->GetVisuallyEnabled() && arguments.compositionSource==arguments.eventSource) - { - if(ProcessKey(arguments.code, arguments.shift, arguments.ctrl)) - { - arguments.handled=true; - } - } - } - - void GuiTextBoxCommonInterface::OnCharInput(compositions::GuiGraphicsComposition* sender, compositions::GuiCharEventArgs& arguments) - { - if(preventEnterDueToAutoComplete) - { - preventEnterDueToAutoComplete=false; - if(arguments.code==VKEY_RETURN) - { - return; - } - } - if(textControl->GetVisuallyEnabled() && arguments.compositionSource==arguments.eventSource) - { - if(!readonly && arguments.code!=VKEY_ESCAPE && arguments.code!=VKEY_BACK && !arguments.ctrl) - { - SetSelectionTextAsKeyInput(WString(arguments.code)); - } - } - } - - void GuiTextBoxCommonInterface::Install( - elements::GuiColorizedTextElement* _textElement, - compositions::GuiGraphicsComposition* _textComposition, - GuiControl* _textControl, - compositions::GuiGraphicsComposition* eventComposition, - compositions::GuiGraphicsComposition* focusableComposition - ) - { - textElement=_textElement; - textComposition=_textComposition; - textControl=_textControl; - textComposition->SetAssociatedCursor(GetCurrentController()->ResourceService()->GetSystemCursor(INativeCursor::IBeam)); - SelectionChanged.SetAssociatedComposition(eventComposition); - UndoRedoChanged.SetAssociatedComposition(eventComposition); - ModifiedChanged.SetAssociatedComposition(eventComposition); - - undoRedoProcessor->UndoRedoChanged.Add(this, &GuiTextBoxCommonInterface::InvokeUndoRedoChanged); - undoRedoProcessor->ModifiedChanged.Add(this, &GuiTextBoxCommonInterface::InvokeModifiedChanged); - - focusableComposition->GetEventReceiver()->gotFocus.AttachMethod(this, &GuiTextBoxCommonInterface::OnGotFocus); - focusableComposition->GetEventReceiver()->lostFocus.AttachMethod(this, &GuiTextBoxCommonInterface::OnLostFocus); - focusableComposition->GetEventReceiver()->caretNotify.AttachMethod(this, &GuiTextBoxCommonInterface::OnCaretNotify); - textComposition->GetEventReceiver()->leftButtonDown.AttachMethod(this, &GuiTextBoxCommonInterface::OnLeftButtonDown); - textComposition->GetEventReceiver()->leftButtonUp.AttachMethod(this, &GuiTextBoxCommonInterface::OnLeftButtonUp); - textComposition->GetEventReceiver()->mouseMove.AttachMethod(this, &GuiTextBoxCommonInterface::OnMouseMove); - focusableComposition->GetEventReceiver()->keyDown.AttachMethod(this, &GuiTextBoxCommonInterface::OnKeyDown); - focusableComposition->GetEventReceiver()->charInput.AttachMethod(this, &GuiTextBoxCommonInterface::OnCharInput); - - for(vint i=0;iAttach(textElement, elementModifyLock, textComposition ,editVersion); - } - } - - GuiTextBoxCommonInterface::ICallback* GuiTextBoxCommonInterface::GetCallback() - { - return callback; - } - - void GuiTextBoxCommonInterface::SetCallback(ICallback* value) - { - callback=value; - } - - bool GuiTextBoxCommonInterface::AttachTextEditCallback(Ptr value) - { - if(textEditCallbacks.Contains(value.Obj())) - { - return false; - } - else - { - textEditCallbacks.Add(value); - if(textElement) - { - value->Attach(textElement, elementModifyLock, textComposition, editVersion); - } - return true; - } - } - - bool GuiTextBoxCommonInterface::DetachTextEditCallback(Ptr value) - { - if(textEditCallbacks.Remove(value.Obj())) - { - value->Detach(); - return true; - } - else - { - return false; - } - } - - void GuiTextBoxCommonInterface::AddShortcutCommand(vint key, const Func& eventHandler) - { - IGuiShortcutKeyItem* item=internalShortcutKeyManager->CreateShortcut(true, false, false, key); - item->Executed.AttachLambda([=](GuiGraphicsComposition* sender, GuiEventArgs& arguments) - { - eventHandler(); - }); - } - - elements::GuiColorizedTextElement* GuiTextBoxCommonInterface::GetTextElement() - { - return textElement; - } - - void GuiTextBoxCommonInterface::UnsafeSetText(const WString& value) - { - if(textElement) - { - TextPos end; - if(textElement->GetLines().GetCount()>0) - { - end.row=textElement->GetLines().GetCount()-1; - end.column=textElement->GetLines().GetLine(end.row).dataLength; - } - Modify(TextPos(), end, value, false); - } - } - - GuiTextBoxCommonInterface::GuiTextBoxCommonInterface() - :textElement(0) - ,textComposition(0) - ,editVersion(0) - ,textControl(0) - ,callback(0) - ,dragging(false) - ,readonly(false) - ,preventEnterDueToAutoComplete(false) - { - undoRedoProcessor=new GuiTextBoxUndoRedoProcessor; - AttachTextEditCallback(undoRedoProcessor); - - internalShortcutKeyManager=new GuiShortcutKeyManager; - AddShortcutCommand('Z', Func(this, &GuiTextBoxCommonInterface::Undo)); - AddShortcutCommand('Y', Func(this, &GuiTextBoxCommonInterface::Redo)); - AddShortcutCommand('A', Func(this, &GuiTextBoxCommonInterface::SelectAll)); - AddShortcutCommand('X', Func(this, &GuiTextBoxCommonInterface::Cut)); - AddShortcutCommand('C', Func(this, &GuiTextBoxCommonInterface::Copy)); - AddShortcutCommand('V', Func(this, &GuiTextBoxCommonInterface::Paste)); - } - - GuiTextBoxCommonInterface::~GuiTextBoxCommonInterface() - { - if(colorizer) - { - DetachTextEditCallback(colorizer); - colorizer=0; - } - if(undoRedoProcessor) - { - DetachTextEditCallback(undoRedoProcessor); - undoRedoProcessor=0; - } - - for(vint i=0;iDetach(); - } - textEditCallbacks.Clear(); - } - - //================ clipboard operations - - bool GuiTextBoxCommonInterface::CanCut() - { - return !readonly && textElement->GetCaretBegin()!=textElement->GetCaretEnd() && textElement->GetPasswordChar()==L'\0'; - } - - bool GuiTextBoxCommonInterface::CanCopy() - { - return textElement->GetCaretBegin()!=textElement->GetCaretEnd() && textElement->GetPasswordChar()==L'\0'; - } - - bool GuiTextBoxCommonInterface::CanPaste() - { - return !readonly && GetCurrentController()->ClipboardService()->ContainsText() && textElement->GetPasswordChar()==L'\0'; - } - - bool GuiTextBoxCommonInterface::Cut() - { - if(CanCut()) - { - GetCurrentController()->ClipboardService()->SetText(GetSelectionText()); - SetSelectionText(L""); - return true; - } - else - { - return false; - } - } - - bool GuiTextBoxCommonInterface::Copy() - { - if(CanCopy()) - { - GetCurrentController()->ClipboardService()->SetText(GetSelectionText()); - return true; - } - else - { - return false; - } - } - - bool GuiTextBoxCommonInterface::Paste() - { - if(CanPaste()) - { - SetSelectionText(GetCurrentController()->ClipboardService()->GetText()); - return true; - } - else - { - return false; - } - } - - //================ editing control - - bool GuiTextBoxCommonInterface::GetReadonly() - { - return readonly; - } - - void GuiTextBoxCommonInterface::SetReadonly(bool value) - { - readonly=value; - } - - //================ text operations - - void GuiTextBoxCommonInterface::Select(TextPos begin, TextPos end) - { - Move(begin, false); - Move(end, true); - } - - void GuiTextBoxCommonInterface::SelectAll() - { - vint row=textElement->GetLines().GetCount()-1; - Move(TextPos(0, 0), false); - Move(TextPos(row, textElement->GetLines().GetLine(row).dataLength), true); - } - - WString GuiTextBoxCommonInterface::GetSelectionText() - { - TextPos selectionBegin=textElement->GetCaretBegin()GetCaretEnd()?textElement->GetCaretBegin():textElement->GetCaretEnd(); - TextPos selectionEnd=textElement->GetCaretBegin()>textElement->GetCaretEnd()?textElement->GetCaretBegin():textElement->GetCaretEnd(); - return textElement->GetLines().GetText(selectionBegin, selectionEnd); - } - - void GuiTextBoxCommonInterface::SetSelectionText(const WString& value) - { - Modify(textElement->GetCaretBegin(), textElement->GetCaretEnd(), value, false); - } - - void GuiTextBoxCommonInterface::SetSelectionTextAsKeyInput(const WString& value) - { - Modify(textElement->GetCaretBegin(), textElement->GetCaretEnd(), value, true); - } - - WString GuiTextBoxCommonInterface::GetRowText(vint row) - { - TextPos start=textElement->GetLines().Normalize(TextPos(row, 0)); - TextPos end=TextPos(start.row, textElement->GetLines().GetLine(start.row).dataLength); - return GetFragmentText(start, end); - } - - vint GuiTextBoxCommonInterface::GetRowCount() - { - return textElement->GetLines().GetCount(); - } - - WString GuiTextBoxCommonInterface::GetFragmentText(TextPos start, TextPos end) - { - start=textElement->GetLines().Normalize(start); - end=textElement->GetLines().Normalize(end); - return textElement->GetLines().GetText(start, end); - } - - TextPos GuiTextBoxCommonInterface::GetCaretBegin() - { - return textElement->GetCaretBegin(); - } - - TextPos GuiTextBoxCommonInterface::GetCaretEnd() - { - return textElement->GetCaretEnd(); - } - - TextPos GuiTextBoxCommonInterface::GetCaretSmall() - { - TextPos c1=GetCaretBegin(); - TextPos c2=GetCaretEnd(); - return c1c2?c1:c2; - } - - //================ position query - - vint GuiTextBoxCommonInterface::GetRowWidth(vint row) - { - return textElement->GetLines().GetRowWidth(row); - } - - vint GuiTextBoxCommonInterface::GetRowHeight() - { - return textElement->GetLines().GetRowHeight(); - } - - vint GuiTextBoxCommonInterface::GetMaxWidth() - { - return textElement->GetLines().GetMaxWidth(); - } - - vint GuiTextBoxCommonInterface::GetMaxHeight() - { - return textElement->GetLines().GetMaxHeight(); - } - - TextPos GuiTextBoxCommonInterface::GetTextPosFromPoint(Point point) - { - Point view=textElement->GetViewPosition(); - return textElement->GetLines().GetTextPosFromPoint(Point(point.x+view.x, point.y+view.y)); - } - - Point GuiTextBoxCommonInterface::GetPointFromTextPos(TextPos pos) - { - Point view=textElement->GetViewPosition(); - Point result=textElement->GetLines().GetPointFromTextPos(pos); - return Point(result.x-view.x, result.y-view.y); - } - - Rect GuiTextBoxCommonInterface::GetRectFromTextPos(TextPos pos) - { - Point view=textElement->GetViewPosition(); - Rect result=textElement->GetLines().GetRectFromTextPos(pos); - return Rect(Point(result.x1-view.x, result.y1-view.y), result.GetSize()); - } - - TextPos GuiTextBoxCommonInterface::GetNearestTextPos(Point point) - { - Point viewPosition=textElement->GetViewPosition(); - Point mousePosition=Point(point.x+viewPosition.x, point.y+viewPosition.y); - TextPos pos=textElement->GetLines().GetTextPosFromPoint(mousePosition); - if(pos.columnGetLines().GetLine(pos.row).dataLength) - { - Rect rect=textElement->GetLines().GetRectFromTextPos(pos); - if(abs((int)(rect.x1-mousePosition.x))>=abs((int)(rect.x2-1-mousePosition.x))) - { - pos.column++; - } - } - return pos; - } - - //================ colorizing - - Ptr GuiTextBoxCommonInterface::GetColorizer() - { - return colorizer; - } - - void GuiTextBoxCommonInterface::SetColorizer(Ptr value) - { - if (!filledDefaultColors) - { - filledDefaultColors = true; - CopyFrom(defaultColors, GetTextElement()->GetColors()); - } - - if(colorizer) - { - DetachTextEditCallback(colorizer); - } - colorizer=value; - if(colorizer) - { - AttachTextEditCallback(colorizer); - GetTextElement()->SetColors(colorizer->GetColors()); - } - else - { - GetTextElement()->SetColors(defaultColors); - GetTextElement()->ResetTextColorIndex(0); - } - } - - //================ auto complete - - Ptr GuiTextBoxCommonInterface::GetAutoComplete() - { - return autoComplete; - } - - void GuiTextBoxCommonInterface::SetAutoComplete(Ptr value) - { - if(autoComplete) - { - DetachTextEditCallback(autoComplete); - } - autoComplete=value; - if(autoComplete) - { - AttachTextEditCallback(autoComplete); - } - } - - //================ undo redo control - - vuint GuiTextBoxCommonInterface::GetEditVersion() - { - return editVersion; - } - - bool GuiTextBoxCommonInterface::CanUndo() - { - return !readonly && undoRedoProcessor->CanUndo(); - } - - bool GuiTextBoxCommonInterface::CanRedo() - { - return !readonly && undoRedoProcessor->CanRedo(); - } - - void GuiTextBoxCommonInterface::ClearUndoRedo() - { - undoRedoProcessor->ClearUndoRedo(); - } - - bool GuiTextBoxCommonInterface::GetModified() - { - return undoRedoProcessor->GetModified(); - } - - void GuiTextBoxCommonInterface::NotifyModificationSaved() - { - undoRedoProcessor->NotifyModificationSaved(); - } - - bool GuiTextBoxCommonInterface::Undo() - { - if(CanUndo()) - { - return undoRedoProcessor->Undo(); - } - else - { - return false; - } - } - - bool GuiTextBoxCommonInterface::Redo() - { - if(CanRedo()) - { - return undoRedoProcessor->Redo(); - } - else - { - return false; - } - } - } - } -} - -/*********************************************************************** -.\CONTROLS\TEXTEDITORPACKAGE\GUITEXTCONTROLS.CPP -***********************************************************************/ - -namespace vl -{ - namespace presentation - { - namespace controls - { - using namespace elements; - using namespace elements::text; - using namespace compositions; - using namespace collections; - -/*********************************************************************** -GuiMultilineTextBox::DefaultTextElementOperatorCallback -***********************************************************************/ - - GuiMultilineTextBox::TextElementOperatorCallback::TextElementOperatorCallback(GuiMultilineTextBox* _textControl) - :GuiTextBoxCommonInterface::DefaultCallback( - _textControl->textElement, - _textControl->textComposition - ) - ,textControl(_textControl) - { - } - - void GuiMultilineTextBox::TextElementOperatorCallback::AfterModify(TextPos originalStart, TextPos originalEnd, const WString& originalText, TextPos inputStart, TextPos inputEnd, const WString& inputText) - { - textControl->CalculateView(); - } - - void GuiMultilineTextBox::TextElementOperatorCallback::ScrollToView(Point point) - { - point.x+=TextMargin; - point.y+=TextMargin; - Point oldPoint(textControl->GetHorizontalScroll()->GetPosition(), textControl->GetVerticalScroll()->GetPosition()); - vint marginX=0; - vint marginY=0; - if(oldPoint.xpoint.x) - { - marginX=-TextMargin; - } - if(oldPoint.ypoint.y) - { - marginY=-TextMargin; - } - textControl->GetHorizontalScroll()->SetPosition(point.x+marginX); - textControl->GetVerticalScroll()->SetPosition(point.y+marginY); - } - - vint GuiMultilineTextBox::TextElementOperatorCallback::GetTextMargin() - { - return TextMargin; - } - -/*********************************************************************** -GuiMultilineTextBox::CommandExecutor -***********************************************************************/ - - GuiMultilineTextBox::CommandExecutor::CommandExecutor(GuiMultilineTextBox* _textBox) - :textBox(_textBox) - { - } - - GuiMultilineTextBox::CommandExecutor::~CommandExecutor() - { - } - - void GuiMultilineTextBox::CommandExecutor::UnsafeSetText(const WString& value) - { - textBox->UnsafeSetText(value); - } - -/*********************************************************************** -GuiMultilineTextBox -***********************************************************************/ - - void GuiMultilineTextBox::BeforeControlTemplateUninstalled_() - { - auto ct = GetControlTemplateObject(); - ct->SetCommands(nullptr); - } - - void GuiMultilineTextBox::AfterControlTemplateInstalled_(bool initialize) - { - auto ct = GetControlTemplateObject(); - Array colors(1); - colors[0] = ct->GetTextColor(); - textElement->SetColors(colors); - textElement->SetCaretColor(ct->GetCaretColor()); - ct->SetCommands(commandExecutor.Obj()); - } - - void GuiMultilineTextBox::CalculateViewAndSetScroll() - { - auto ct = GetControlTemplateObject(); - CalculateView(); - vint smallMove = textElement->GetLines().GetRowHeight(); - vint bigMove = smallMove * 5; - ct->GetHorizontalScroll()->SetSmallMove(smallMove); - ct->GetHorizontalScroll()->SetBigMove(bigMove); - ct->GetVerticalScroll()->SetSmallMove(smallMove); - ct->GetVerticalScroll()->SetBigMove(bigMove); - } - - void GuiMultilineTextBox::OnVisuallyEnabledChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - textElement->SetVisuallyEnabled(GetVisuallyEnabled()); - } - - Size GuiMultilineTextBox::QueryFullSize() - { - text::TextLines& lines = textElement->GetLines(); - return Size(lines.GetMaxWidth() + TextMargin * 2, lines.GetMaxHeight() + TextMargin * 2); - } - - void GuiMultilineTextBox::UpdateView(Rect viewBounds) - { - textElement->SetViewPosition(viewBounds.LeftTop() - Size(TextMargin, TextMargin)); + SubMenuOpeningChanged.Execute(GetNotifyEventArguments()); + GetControlTemplateObject()->SetSubMenuOpening(true); } - void GuiMultilineTextBox::OnRenderTargetChanged(elements::IGuiGraphicsRenderTarget* renderTarget) + void GuiMenuButton::OnSubMenuWindowClosed(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - CalculateViewAndSetScroll(); - GuiScrollView::OnRenderTargetChanged(renderTarget); + SubMenuOpeningChanged.Execute(GetNotifyEventArguments()); + GetControlTemplateObject()->SetSubMenuOpening(false); } - void GuiMultilineTextBox::OnBoundsMouseButtonDown(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) + void GuiMenuButton::OnMouseEnter(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { if(GetVisuallyEnabled()) { - boundsComposition->GetRelatedGraphicsHost()->SetFocus(boundsComposition); + if(cascadeAction && ownerMenuService && ownerMenuService->IsActiveState()) + { + OpenSubMenuInternal(); + } } } - GuiMultilineTextBox::GuiMultilineTextBox(theme::ThemeName themeName) - :GuiScrollView(themeName) + void GuiMenuButton::OnClicked(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - textElement = GuiColorizedTextElement::Create(); - textElement->SetFont(GetFont()); - - textComposition = new GuiBoundsComposition; - textComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); - textComposition->SetOwnedElement(textElement); - containerComposition->AddChild(textComposition); - - callback = new TextElementOperatorCallback(this); - commandExecutor = new CommandExecutor(this); - - SetFocusableComposition(boundsComposition); - Install(textElement, textComposition, this, boundsComposition, focusableComposition); - SetCallback(callback.Obj()); - - VisuallyEnabledChanged.AttachMethod(this, &GuiMultilineTextBox::OnVisuallyEnabledChanged); - boundsComposition->GetEventReceiver()->leftButtonDown.AttachMethod(this, &GuiMultilineTextBox::OnBoundsMouseButtonDown); - boundsComposition->GetEventReceiver()->middleButtonDown.AttachMethod(this, &GuiMultilineTextBox::OnBoundsMouseButtonDown); - boundsComposition->GetEventReceiver()->rightButtonDown.AttachMethod(this, &GuiMultilineTextBox::OnBoundsMouseButtonDown); + if(GetVisuallyEnabled()) + { + if(GetSubMenu()) + { + OpenSubMenuInternal(); + } + else if(ownerMenuService) + { + ownerMenuService->MenuItemExecuted(); + } + } } - GuiMultilineTextBox::~GuiMultilineTextBox() + IGuiMenuService::Direction GuiMenuButton::GetSubMenuDirection() + { + return ownerMenuService?ownerMenuService->GetPreferredDirection():IGuiMenuService::Horizontal; + } + + GuiMenuButton::GuiMenuButton(theme::ThemeName themeName) + :GuiSelectableButton(themeName) + ,subMenu(0) + ,ownedSubMenu(false) + ,ownerMenuService(0) + ,cascadeAction(true) + { + SetAutoSelection(false); + SubMenuOpeningChanged.SetAssociatedComposition(boundsComposition); + ImageChanged.SetAssociatedComposition(boundsComposition); + ShortcutTextChanged.SetAssociatedComposition(boundsComposition); + } + + GuiMenuButton::~GuiMenuButton() + { + if(subMenu && ownedSubMenu) + { + delete subMenu; + } + } + + Ptr GuiMenuButton::GetImage() + { + return image; + } + + void GuiMenuButton::SetImage(Ptr value) + { + if (image != value) + { + image = value; + GetControlTemplateObject()->SetImage(image); + ImageChanged.Execute(GetNotifyEventArguments()); + } + } + + const WString& GuiMenuButton::GetShortcutText() + { + return shortcutText; + } + + void GuiMenuButton::SetShortcutText(const WString& value) + { + if (shortcutText != value) + { + shortcutText = value; + GetControlTemplateObject()->SetShortcutText(shortcutText); + ShortcutTextChanged.Execute(GetNotifyEventArguments()); + } + } + + bool GuiMenuButton::IsSubMenuExists() + { + return subMenu!=0; + } + + GuiMenu* GuiMenuButton::GetSubMenu() + { + return subMenu; + } + + GuiMenu* GuiMenuButton::CreateSubMenu(TemplateProperty subMenuTemplate) + { + if (!subMenu) + { + GuiMenu* newSubMenu = new GuiMenu(theme::ThemeName::Menu, this); + newSubMenu->SetControlTemplate(subMenuTemplate ? subMenuTemplate : GetControlTemplateObject()->GetSubMenuTemplate()); + SetSubMenu(newSubMenu, true); + } + return subMenu; + } + + void GuiMenuButton::SetSubMenu(GuiMenu* value, bool owned) + { + if(subMenu) + { + if(ownedSubMenu) + { + delete subMenu; + } + } + subMenu=value; + ownedSubMenu=owned; + if(subMenu) + { + subMenu->WindowOpened.AttachMethod(this, &GuiMenuButton::OnSubMenuWindowOpened); + subMenu->WindowClosed.AttachMethod(this, &GuiMenuButton::OnSubMenuWindowClosed); + } + GetControlTemplateObject()->SetSubMenuExisting(subMenu != nullptr); + } + + void GuiMenuButton::DestroySubMenu() + { + if(subMenu) + { + if(ownedSubMenu) + { + delete subMenu; + } + subMenu=0; + ownedSubMenu=false; + GetControlTemplateObject()->SetSubMenuExisting(false); + } + } + + bool GuiMenuButton::GetOwnedSubMenu() + { + return subMenu && ownedSubMenu; + } + + bool GuiMenuButton::GetSubMenuOpening() + { + if(subMenu) + { + return subMenu->GetOpening(); + } + else + { + return false; + } + } + + void GuiMenuButton::SetSubMenuOpening(bool value) + { + if(subMenu) + { + if(value) + { + subMenu->SetClientSize(preferredMenuClientSize); + IGuiMenuService::Direction direction=GetSubMenuDirection(); + subMenu->ShowPopup(GetSubMenuHost(), direction==IGuiMenuService::Horizontal); + } + else + { + subMenu->Close(); + } + } + } + + Size GuiMenuButton::GetPreferredMenuClientSize() + { + return preferredMenuClientSize; + } + + void GuiMenuButton::SetPreferredMenuClientSize(Size value) + { + preferredMenuClientSize=value; + } + + bool GuiMenuButton::GetCascadeAction() + { + return cascadeAction; + } + + void GuiMenuButton::SetCascadeAction(bool value) + { + cascadeAction=value; + } + } + } +} + +/*********************************************************************** +.\CONTROLS\GUIDIALOGS.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace controls + { + using namespace elements; + using namespace compositions; + using namespace collections; + using namespace reflection::description; + +/*********************************************************************** +GuiDialogBase +***********************************************************************/ + + GuiWindow* GuiDialogBase::GetHostWindow() + { + if (rootObject) + { + if (auto control = dynamic_cast(rootObject)) + { + if (auto host = control->GetRelatedControlHost()) + { + return dynamic_cast(host); + } + } + else if (auto composition = dynamic_cast(rootObject)) + { + if (auto host = composition->GetRelatedControlHost()) + { + return dynamic_cast(host); + } + } + } + return nullptr; + } + + GuiDialogBase::GuiDialogBase() { } - const WString& GuiMultilineTextBox::GetText() + GuiDialogBase::~GuiDialogBase() { - text = textElement->GetLines().GetText(); - return text; } - void GuiMultilineTextBox::SetText(const WString& value) + void GuiDialogBase::Attach(GuiInstanceRootObject* _rootObject) { - UnsafeSetText(value); - textElement->SetCaretBegin(TextPos(0, 0)); - textElement->SetCaretEnd(TextPos(0, 0)); - CalculateView(); + rootObject = _rootObject; } - void GuiMultilineTextBox::SetFont(const FontProperties& value) + void GuiDialogBase::Detach(GuiInstanceRootObject* _rootObject) { - GuiControl::SetFont(value); - textElement->SetFont(value); - CalculateViewAndSetScroll(); + rootObject = nullptr; } /*********************************************************************** -GuiSinglelineTextBox::DefaultTextElementOperatorCallback +GuiMessageDialog ***********************************************************************/ - GuiSinglelineTextBox::TextElementOperatorCallback::TextElementOperatorCallback(GuiSinglelineTextBox* _textControl) - :GuiTextBoxCommonInterface::DefaultCallback( - _textControl->textElement, - _textControl->textComposition - ) + GuiMessageDialog::GuiMessageDialog() { } - bool GuiSinglelineTextBox::TextElementOperatorCallback::BeforeModify(TextPos start, TextPos end, const WString& originalText, WString& inputText) + GuiMessageDialog::~GuiMessageDialog() { - vint length=inputText.Length(); - const wchar_t* input=inputText.Buffer(); - for(vint i=0;iDialogService(); + return service->ShowMessageBox(GetHostWindow()->GetNativeWindow(), text, title, input, defaultButton, icon, modalOption); + } + +/*********************************************************************** +GuiColorDialog +***********************************************************************/ + + GuiColorDialog::GuiColorDialog() + { + for (vint i = 0; i < 16; i++) { - if(*input==0 || *input==L'\r' || *input==L'\n') - { - length=i; - break; - } + customColors.Add(Color()); } - if(length!=inputText.Length()) + } + + GuiColorDialog::~GuiColorDialog() + { + } + + bool GuiColorDialog::GetEnabledCustomColor() + { + return enabledCustomColor; + } + + void GuiColorDialog::SetEnabledCustomColor(bool value) + { + enabledCustomColor = value; + } + + bool GuiColorDialog::GetOpenedCustomColor() + { + return openedCustomColor; + } + + void GuiColorDialog::SetOpenedCustomColor(bool value) + { + openedCustomColor = value; + } + + Color GuiColorDialog::GetSelectedColor() + { + return selectedColor; + } + + void GuiColorDialog::SetSelectedColor(Color value) + { + if (selectedColor != value) { - inputText=inputText.Left(length); + selectedColor = value; + SelectedColorChanged.Execute(GuiEventArgs()); + } + } + + collections::List& GuiColorDialog::GetCustomColors() + { + return customColors; + } + + bool GuiColorDialog::ShowDialog() + { + Array colors; + CopyFrom(colors, customColors); + colors.Resize(16); + + INativeDialogService::ColorDialogCustomColorOptions options = + !enabledCustomColor ? INativeDialogService::CustomColorDisabled : + !openedCustomColor ? INativeDialogService::CustomColorEnabled : + INativeDialogService::CustomColorOpened; + + auto service = GetCurrentController()->DialogService(); + if (!service->ShowColorDialog(GetHostWindow()->GetNativeWindow(), selectedColor, showSelection, options, &colors[0])) + { + return false; + } + + CopyFrom(customColors, colors); + SelectedColorChanged.Execute(GuiEventArgs()); + return true; + } + +/*********************************************************************** +GuiFontDialog +***********************************************************************/ + + GuiFontDialog::GuiFontDialog() + { + } + + GuiFontDialog::~GuiFontDialog() + { + } + + const FontProperties& GuiFontDialog::GetSelectedFont() + { + return selectedFont; + } + + void GuiFontDialog::SetSelectedFont(const FontProperties& value) + { + if (selectedFont != value) + { + selectedFont = value; + SelectedFontChanged.Execute(GuiEventArgs()); + } + } + + Color GuiFontDialog::GetSelectedColor() + { + return selectedColor; + } + + void GuiFontDialog::SetSelectedColor(Color value) + { + if (selectedColor != value) + { + selectedColor = value; + SelectedColorChanged.Execute(GuiEventArgs()); + } + } + + bool GuiFontDialog::GetShowSelection() + { + return showSelection; + } + + void GuiFontDialog::SetShowSelection(bool value) + { + showSelection = value; + } + + bool GuiFontDialog::GetShowEffect() + { + return showEffect; + } + + void GuiFontDialog::SetShowEffect(bool value) + { + showEffect = value; + } + + bool GuiFontDialog::GetForceFontExist() + { + return forceFontExist; + } + + void GuiFontDialog::SetForceFontExist(bool value) + { + forceFontExist = value; + } + + bool GuiFontDialog::ShowDialog() + { + auto service = GetCurrentController()->DialogService(); + if (!service->ShowFontDialog(GetHostWindow()->GetNativeWindow(), selectedFont, selectedColor, showSelection, showEffect, forceFontExist)) + { + return false; + } + + SelectedColorChanged.Execute(GuiEventArgs()); + SelectedFontChanged.Execute(GuiEventArgs()); + return true; + } + +/*********************************************************************** +GuiFileDialogBase +***********************************************************************/ + + GuiFileDialogBase::GuiFileDialogBase() + { + } + + GuiFileDialogBase::~GuiFileDialogBase() + { + } + + const WString& GuiFileDialogBase::GetFilter() + { + return filter; + } + + void GuiFileDialogBase::SetFilter(const WString& value) + { + filter = value; + } + + vint GuiFileDialogBase::GetFilterIndex() + { + return filterIndex; + } + + void GuiFileDialogBase::SetFilterIndex(vint value) + { + if (filterIndex != value) + { + filterIndex = value; + FilterIndexChanged.Execute(GuiEventArgs()); + } + } + + bool GuiFileDialogBase::GetEnabledPreview() + { + return enabledPreview; + } + + void GuiFileDialogBase::SetEnabledPreview(bool value) + { + enabledPreview = value; + } + + WString GuiFileDialogBase::GetTitle() + { + return title; + } + + void GuiFileDialogBase::SetTitle(const WString& value) + { + title = value; + } + + WString GuiFileDialogBase::GetFileName() + { + return fileName; + } + + void GuiFileDialogBase::SetFileName(const WString& value) + { + if (fileName != value) + { + FileNameChanged.Execute(GuiEventArgs()); + } + } + + WString GuiFileDialogBase::GetDirectory() + { + return directory; + } + + void GuiFileDialogBase::SetDirectory(const WString& value) + { + directory = value; + } + + WString GuiFileDialogBase::GetDefaultExtension() + { + return defaultExtension; + } + + void GuiFileDialogBase::SetDefaultExtension(const WString& value) + { + defaultExtension = value; + } + + INativeDialogService::FileDialogOptions GuiFileDialogBase::GetOptions() + { + return options; + } + + void GuiFileDialogBase::SetOptions(INativeDialogService::FileDialogOptions value) + { + options = value; + } + +/*********************************************************************** +GuiOpenFileDialog +***********************************************************************/ + + GuiOpenFileDialog::GuiOpenFileDialog() + { + } + + GuiOpenFileDialog::~GuiOpenFileDialog() + { + } + + collections::List& GuiOpenFileDialog::GetFileNames() + { + return fileNames; + } + + bool GuiOpenFileDialog::ShowDialog() + { + fileNames.Clear(); + auto service = GetCurrentController()->DialogService(); + if (!service->ShowFileDialog( + GetHostWindow()->GetNativeWindow(), + fileNames, + filterIndex, + (enabledPreview ? INativeDialogService::FileDialogOpenPreview : INativeDialogService::FileDialogOpen), + title, + fileName, + directory, + defaultExtension, + filter, + options)) + { + return false; + } + + if (fileNames.Count() > 0) + { + fileName = fileNames[0]; + FileNameChanged.Execute(GuiEventArgs()); + FilterIndexChanged.Execute(GuiEventArgs()); } return true; } - void GuiSinglelineTextBox::TextElementOperatorCallback::AfterModify(TextPos originalStart, TextPos originalEnd, const WString& originalText, TextPos inputStart, TextPos inputEnd, const WString& inputText) - { - } - - void GuiSinglelineTextBox::TextElementOperatorCallback::ScrollToView(Point point) - { - vint newX=point.x; - vint oldX=textElement->GetViewPosition().x; - vint marginX=0; - if(oldXnewX) - { - marginX=-TextMargin; - } - - newX+=marginX; - vint minX=-TextMargin; - vint maxX=textElement->GetLines().GetMaxWidth()+TextMargin-textComposition->GetBounds().Width(); - if(newX>=maxX) - { - newX=maxX-1; - } - if(newXSetViewPosition(Point(newX, -TextMargin)); - } - - vint GuiSinglelineTextBox::TextElementOperatorCallback::GetTextMargin() - { - return TextMargin; - } - /*********************************************************************** -GuiSinglelineTextBox +GuiSaveFileDialog ***********************************************************************/ - void GuiSinglelineTextBox::BeforeControlTemplateUninstalled_() + GuiSaveFileDialog::GuiSaveFileDialog() { } - void GuiSinglelineTextBox::AfterControlTemplateInstalled_(bool initialize) + GuiSaveFileDialog::~GuiSaveFileDialog() { - auto ct = GetControlTemplateObject(); - Array colors(1); - colors[0] = ct->GetTextColor(); - textElement->SetColors(colors); - textElement->SetCaretColor(ct->GetCaretColor()); } - void GuiSinglelineTextBox::RearrangeTextElement() + bool GuiSaveFileDialog::ShowDialog() { - textCompositionTable->SetRowOption( - 1, - GuiCellOption::AbsoluteOption( - textElement->GetLines().GetRowHeight() + 2 * TextMargin) - ); - } - - void GuiSinglelineTextBox::OnRenderTargetChanged(elements::IGuiGraphicsRenderTarget* renderTarget) - { - GuiControl::OnRenderTargetChanged(renderTarget); - RearrangeTextElement(); - } - - void GuiSinglelineTextBox::OnVisuallyEnabledChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - textElement->SetVisuallyEnabled(GetVisuallyEnabled()); - } - - void GuiSinglelineTextBox::OnBoundsMouseButtonDown(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) - { - if(GetVisuallyEnabled()) + List fileNames; + auto service = GetCurrentController()->DialogService(); + if (!service->ShowFileDialog( + GetHostWindow()->GetNativeWindow(), + fileNames, + filterIndex, + (enabledPreview ? INativeDialogService::FileDialogSavePreview : INativeDialogService::FileDialogSave), + title, + fileName, + directory, + defaultExtension, + filter, + options)) { - boundsComposition->GetRelatedGraphicsHost()->SetFocus(boundsComposition); + return false; } - } - GuiSinglelineTextBox::GuiSinglelineTextBox(theme::ThemeName themeName) - :GuiControl(themeName) - { - textElement = GuiColorizedTextElement::Create(); - textElement->SetFont(GetFont()); - textElement->SetViewPosition(Point(-GuiSinglelineTextBox::TextMargin, -GuiSinglelineTextBox::TextMargin)); - - textCompositionTable = new GuiTableComposition; - textCompositionTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - textCompositionTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); - textCompositionTable->SetRowsAndColumns(3, 1); - textCompositionTable->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); - textCompositionTable->SetRowOption(1, GuiCellOption::AbsoluteOption(0)); - textCompositionTable->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); - textCompositionTable->SetColumnOption(0, GuiCellOption::PercentageOption(1.0)); - containerComposition->AddChild(textCompositionTable); - - textComposition = new GuiCellComposition; - textComposition->SetOwnedElement(textElement); - textCompositionTable->AddChild(textComposition); - textComposition->SetSite(1, 0, 1, 1); - - callback = new TextElementOperatorCallback(this); - SetFocusableComposition(boundsComposition); - Install(textElement, textComposition, this, boundsComposition, focusableComposition); - SetCallback(callback.Obj()); - - VisuallyEnabledChanged.AttachMethod(this, &GuiSinglelineTextBox::OnVisuallyEnabledChanged); - boundsComposition->GetEventReceiver()->leftButtonDown.AttachMethod(this, &GuiSinglelineTextBox::OnBoundsMouseButtonDown); - boundsComposition->GetEventReceiver()->middleButtonDown.AttachMethod(this, &GuiSinglelineTextBox::OnBoundsMouseButtonDown); - boundsComposition->GetEventReceiver()->rightButtonDown.AttachMethod(this, &GuiSinglelineTextBox::OnBoundsMouseButtonDown); - } - - GuiSinglelineTextBox::~GuiSinglelineTextBox() - { - } - - const WString& GuiSinglelineTextBox::GetText() - { - text = textElement->GetLines().GetText(); - return text; - } - - void GuiSinglelineTextBox::SetText(const WString& value) - { - UnsafeSetText(value); - textElement->SetCaretBegin(TextPos(0, 0)); - textElement->SetCaretEnd(TextPos(0, 0)); - } - - void GuiSinglelineTextBox::SetFont(const FontProperties& value) - { - GuiControl::SetFont(value); - textElement->SetFont(value); - RearrangeTextElement(); - } - - wchar_t GuiSinglelineTextBox::GetPasswordChar() - { - return textElement->GetPasswordChar(); - } - - void GuiSinglelineTextBox::SetPasswordChar(wchar_t value) - { - textElement->SetPasswordChar(value); + if (fileNames.Count() > 0) + { + fileName = fileNames[0]; + FileNameChanged.Execute(GuiEventArgs()); + FilterIndexChanged.Execute(GuiEventArgs()); + } + return true; } } } @@ -16478,3672 +20064,6 @@ GuiBindableTreeView } -/*********************************************************************** -.\CONTROLS\LISTCONTROLPACKAGE\GUIDATAGRIDCONTROLS.CPP -***********************************************************************/ - -namespace vl -{ - namespace presentation - { - namespace controls - { - namespace list - { - using namespace compositions; - using namespace collections; - using namespace description; - using namespace templates; - - const wchar_t* const IDataGridView::Identifier = L"vl::presentation::controls::list::IDataGridView"; - -/*********************************************************************** -DefaultDataGridItemTemplate -***********************************************************************/ - - IDataVisualizerFactory* DefaultDataGridItemTemplate::GetDataVisualizerFactory(vint row, vint column) - { - if (auto dataGrid = dynamic_cast(listControl)) - { - if (auto factory = dataGrid->dataGridView->GetCellDataVisualizerFactory(row, column)) - { - return factory; - } - - if (column == 0) - { - return dataGrid->defaultMainColumnVisualizerFactory.Obj(); - } - else - { - return dataGrid->defaultSubColumnVisualizerFactory.Obj(); - } - - } - - return nullptr; - } - - IDataEditorFactory* DefaultDataGridItemTemplate::GetDataEditorFactory(vint row, vint column) - { - if (auto dataGrid = dynamic_cast(listControl)) - { - return dataGrid->dataGridView->GetCellDataEditorFactory(row, column); - } - return nullptr; - } - - vint DefaultDataGridItemTemplate::GetCellColumnIndex(compositions::GuiGraphicsComposition* composition) - { - for (vint i = 0; i < textTable->GetColumns(); i++) - { - auto cell = textTable->GetSitedCell(0, i); - if (composition == cell) - { - return i; - } - } - return -1; - } - - void DefaultDataGridItemTemplate::OnCellButtonUp(compositions::GuiGraphicsComposition* sender, bool openEditor) - { - if (auto dataGrid = dynamic_cast(listControl)) - { - vint index = GetCellColumnIndex(sender); - if (index != -1) - { - if (currentEditor && dataGrid->GetSelectedCell().column == index) - { - return; - } - - vint currentRow = GetIndex(); - dataGrid->StartEdit(currentRow, index); - } - } - } - - bool DefaultDataGridItemTemplate::IsInEditor(compositions::GuiMouseEventArgs& arguments) - { - if (auto dataGrid = dynamic_cast(listControl)) - { - if (!dataGrid->currentEditor) return false; - auto editorComposition = dataGrid->currentEditor->GetTemplate(); - auto currentComposition = arguments.eventSource; - - while (currentComposition) - { - if (currentComposition == editorComposition) - { - arguments.handled = true; - return true; - } - else if (currentComposition == this) - { - break; - } - else - { - currentComposition = currentComposition->GetParent(); - } - } - - } - return false; - } - - void DefaultDataGridItemTemplate::OnCellButtonDown(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) - { - IsInEditor(arguments); - } - - void DefaultDataGridItemTemplate::OnCellLeftButtonUp(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) - { - if (auto dataGrid = dynamic_cast(listControl)) - { - if (!IsInEditor(arguments)) - { - if (dataGrid->GetVisuallyEnabled()) - { - OnCellButtonUp(sender, true); - } - } - } - } - - void DefaultDataGridItemTemplate::OnCellRightButtonUp(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) - { - if (auto dataGrid = dynamic_cast(listControl)) - { - if (!IsInEditor(arguments)) - { - if (dataGrid->GetVisuallyEnabled()) - { - OnCellButtonUp(sender, false); - } - } - } - } - - void DefaultDataGridItemTemplate::OnColumnChanged() - { - UpdateSubItemSize(); - } - - void DefaultDataGridItemTemplate::OnInitialize() - { - DefaultListViewItemTemplate::OnInitialize(); - { - textTable = new GuiTableComposition; - textTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); - textTable->SetRowsAndColumns(1, 1); - textTable->SetRowOption(0, GuiCellOption::MinSizeOption()); - textTable->SetColumnOption(0, GuiCellOption::AbsoluteOption(0)); - AddChild(textTable); - } - - if (auto dataGrid = dynamic_cast(listControl)) - { - vint columnCount = dataGrid->listViewItemView->GetColumnCount(); - vint itemIndex = GetIndex(); - - dataVisualizers.Resize(columnCount); - for (vint i = 0; i < dataVisualizers.Count(); i++) - { - auto factory = GetDataVisualizerFactory(itemIndex, i); - dataVisualizers[i] = factory->CreateVisualizer(dataGrid); - } - - textTable->SetRowsAndColumns(1, columnCount); - for (vint i = 0; i < columnCount; i++) - { - auto cell = new GuiCellComposition; - textTable->AddChild(cell); - cell->SetSite(0, i, 1, 1); - cell->GetEventReceiver()->leftButtonDown.AttachMethod(this, &DefaultDataGridItemTemplate::OnCellButtonDown); - cell->GetEventReceiver()->rightButtonDown.AttachMethod(this, &DefaultDataGridItemTemplate::OnCellButtonDown); - cell->GetEventReceiver()->leftButtonUp.AttachMethod(this, &DefaultDataGridItemTemplate::OnCellLeftButtonUp); - cell->GetEventReceiver()->rightButtonUp.AttachMethod(this, &DefaultDataGridItemTemplate::OnCellRightButtonUp); - - auto composition = dataVisualizers[i]->GetTemplate(); - composition->SetAlignmentToParent(Margin(0, 0, 0, 0)); - cell->AddChild(composition); - } - - for (vint i = 0; i < dataVisualizers.Count(); i++) - { - dataVisualizers[i]->BeforeVisualizeCell(dataGrid->GetItemProvider(), itemIndex, i); - } - - GridPos selectedCell = dataGrid->GetSelectedCell(); - if (selectedCell.row == itemIndex) - { - NotifySelectCell(selectedCell.column); - } - else - { - NotifySelectCell(-1); - } - UpdateSubItemSize(); - } - - SelectedChanged.AttachMethod(this, &DefaultDataGridItemTemplate::OnSelectedChanged); - FontChanged.AttachMethod(this, &DefaultDataGridItemTemplate::OnFontChanged); - - SelectedChanged.Execute(compositions::GuiEventArgs(this)); - FontChanged.Execute(compositions::GuiEventArgs(this)); - } - - void DefaultDataGridItemTemplate::OnSelectedChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if (!GetSelected()) - { - NotifySelectCell(-1); - } - } - - void DefaultDataGridItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - FOREACH(Ptr, visualizer, dataVisualizers) - { - visualizer->GetTemplate()->SetFont(GetFont()); - } - if (currentEditor) - { - currentEditor->GetTemplate()->SetFont(GetFont()); - } - } - - DefaultDataGridItemTemplate::DefaultDataGridItemTemplate() - { - } - - DefaultDataGridItemTemplate::~DefaultDataGridItemTemplate() - { - FOREACH(Ptr, visualizer, dataVisualizers) - { - visualizer->NotifyDeletedTemplate(); - } - if (currentEditor) - { - currentEditor->NotifyDeletedTemplate(); - } - } - - void DefaultDataGridItemTemplate::UpdateSubItemSize() - { - if (auto dataGrid = dynamic_cast(listControl)) - { - vint columnCount = dataGrid->listViewItemView->GetColumnCount(); - if (columnCount > textTable->GetColumns()) - { - columnCount = textTable->GetColumns(); - } - for (vint i = 0; i < columnCount; i++) - { - textTable->SetColumnOption(i, GuiCellOption::AbsoluteOption(dataGrid->columnItemView->GetColumnSize(i))); - } - textTable->UpdateCellBounds(); - } - } - - bool DefaultDataGridItemTemplate::IsEditorOpened() - { - return currentEditor != nullptr; - } - - void DefaultDataGridItemTemplate::NotifyOpenEditor(vint column, IDataEditor* editor) - { - currentEditor = editor; - if (currentEditor) - { - auto cell = textTable->GetSitedCell(0, column); - auto* editorBounds = currentEditor->GetTemplate(); - if (editorBounds->GetParent() && editorBounds->GetParent() != cell) - { - editorBounds->GetParent()->RemoveChild(editorBounds); - } - editorBounds->SetAlignmentToParent(Margin(0, 0, 0, 0)); - cell->AddChild(editorBounds); - if (auto focusControl = currentEditor->GetTemplate()->GetFocusControl()) - { - focusControl->SetFocus(); - } - } - } - - void DefaultDataGridItemTemplate::NotifyCloseEditor() - { - if (currentEditor) - { - auto composition = currentEditor->GetTemplate(); - if (composition->GetParent()) - { - composition->GetParent()->RemoveChild(composition); - } - currentEditor = nullptr; - } - } - - void DefaultDataGridItemTemplate::NotifySelectCell(vint column) - { - for (vint i = 0; i < dataVisualizers.Count(); i++) - { - dataVisualizers[i]->SetSelected(i == column); - } - } - - void DefaultDataGridItemTemplate::NotifyCellEdited() - { - for (vint i = 0; i < dataVisualizers.Count(); i++) - { - dataVisualizers[i]->BeforeVisualizeCell(listControl->GetItemProvider(), GetIndex(), i); - } - } - } - -/*********************************************************************** -GuiVirtualDataGrid (Editor) -***********************************************************************/ - - using namespace list; - - void GuiVirtualDataGrid::OnItemModified(vint start, vint count, vint newCount) - { - GuiVirtualListView::OnItemModified(start, count, newCount); - if(!GetItemProvider()->IsEditing()) - { - StopEdit(false); - } - } - - void GuiVirtualDataGrid::OnStyleUninstalled(ItemStyle* style) - { - GuiVirtualListView::OnStyleUninstalled(style); - if (auto itemStyle = dynamic_cast(style)) - { - if (itemStyle->IsEditorOpened()) - { - itemStyle->NotifyCloseEditor(); - currentEditor = nullptr; - currentEditorPos = { -1,-1 }; - } - } - } - - void GuiVirtualDataGrid::NotifyCloseEditor() - { - if (currentEditorPos.row != -1 && GetArranger()) - { - auto style = GetArranger()->GetVisibleStyle(currentEditorPos.row); - if (auto itemStyle = dynamic_cast(style)) - { - itemStyle->NotifyCloseEditor(); - } - } - } - - void GuiVirtualDataGrid::NotifySelectCell(vint row, vint column) - { - selectedCell = { row, column }; - SelectedCellChanged.Execute(GetNotifyEventArguments()); - - auto style = GetArranger()->GetVisibleStyle(row); - if (auto itemStyle = dynamic_cast(style)) - { - itemStyle->NotifySelectCell(column); - } - } - - bool GuiVirtualDataGrid::StartEdit(vint row, vint column) - { - StopEdit(true); - NotifySelectCell(row, column); - - auto style = GetArranger()->GetVisibleStyle(row); - if (auto itemStyle = dynamic_cast(style)) - { - if (auto factory = dataGridView->GetCellDataEditorFactory(row, column)) - { - currentEditorOpeningEditor = true; - currentEditorPos = { row,column }; - currentEditor = factory->CreateEditor(this); - currentEditor->BeforeEditCell(GetItemProvider(), row, column); - itemStyle->NotifyOpenEditor(column, currentEditor.Obj()); - currentEditorOpeningEditor = false; - return true; - } - } - return false; - } - - void GuiVirtualDataGrid::StopEdit(bool forOpenNewEditor) - { - if (GetItemProvider()->IsEditing()) - { - NotifyCloseEditor(); - } - else - { - if (currentEditorPos != GridPos{-1, -1}) - { - if (currentEditor) - { - NotifyCloseEditor(); - } - if (!forOpenNewEditor) - { - NotifySelectCell(-1, -1); - } - } - } - currentEditor = nullptr; - currentEditorPos = { -1,-1 }; - } - -/*********************************************************************** -GuiVirtualDataGrid (IDataGridContext) -***********************************************************************/ - - templates::GuiListViewTemplate* GuiVirtualDataGrid::GetListViewControlTemplate() - { - return GetControlTemplateObject(); - } - - description::Value GuiVirtualDataGrid::GetViewModelContext() - { - return dataGridView->GetViewModelContext(); - } - - void GuiVirtualDataGrid::RequestSaveData() - { - if (currentEditor && !currentEditorOpeningEditor) - { - GuiControl* focusedControl = nullptr; - if (auto controlHost = GetRelatedControlHost()) - { - if (auto graphicsHost = controlHost->GetGraphicsHost()) - { - if (auto focusComposition = graphicsHost->GetFocusedComposition()) - { - focusedControl = focusComposition->GetRelatedControl(); - } - } - } - - GetItemProvider()->PushEditing(); - dataGridView->SetBindingCellValue(currentEditorPos.row, currentEditorPos.column, currentEditor->GetTemplate()->GetCellValue()); - GetItemProvider()->PopEditing(); - - auto style = GetArranger()->GetVisibleStyle(currentEditorPos.row); - if (auto itemStyle = dynamic_cast(style)) - { - itemStyle->NotifyCellEdited(); - } - - if (currentEditor && focusedControl) - { - focusedControl->SetFocus(); - } - } - } - -/*********************************************************************** -GuiVirtualDataGrid -***********************************************************************/ - - void GuiVirtualDataGrid::OnColumnClicked(compositions::GuiGraphicsComposition* sender, compositions::GuiItemEventArgs& arguments) - { - if(dataGridView->IsColumnSortable(arguments.itemIndex)) - { - switch(columnItemView->GetSortingState(arguments.itemIndex)) - { - case ColumnSortingState::NotSorted: - dataGridView->SortByColumn(arguments.itemIndex, true); - break; - case ColumnSortingState::Ascending: - dataGridView->SortByColumn(arguments.itemIndex, false); - break; - case ColumnSortingState::Descending: - dataGridView->SortByColumn(-1, false); - break; - } - } - } - - GuiVirtualDataGrid::GuiVirtualDataGrid(theme::ThemeName themeName, GuiListControl::IItemProvider* _itemProvider) - :GuiVirtualListView(themeName, _itemProvider) - { - listViewItemView = dynamic_cast(_itemProvider->RequestView(IListViewItemView::Identifier)); - columnItemView = dynamic_cast(_itemProvider->RequestView(ListViewColumnItemArranger::IColumnItemView::Identifier)); - dataGridView = dynamic_cast(_itemProvider->RequestView(IDataGridView::Identifier)); - - { - auto mainProperty = [](const Value&) { return new MainColumnVisualizerTemplate; }; - auto subProperty = [](const Value&) { return new SubColumnVisualizerTemplate; }; - auto cellBorderProperty = [](const Value&) { return new CellBorderVisualizerTemplate; }; - - auto mainFactory = MakePtr(mainProperty); - auto subFactory = MakePtr(subProperty); - defaultMainColumnVisualizerFactory = MakePtr(cellBorderProperty, mainFactory); - defaultSubColumnVisualizerFactory = MakePtr(cellBorderProperty, subFactory); - } - - CHECK_ERROR(listViewItemView != nullptr, L"GuiVirtualDataGrid::GuiVirtualDataGrid(IStyleController*, GuiListControl::IItemProvider*)#Missing IListViewItemView from item provider."); - CHECK_ERROR(columnItemView != nullptr, L"GuiVirtualDataGrid::GuiVirtualDataGrid(IStyleController*, GuiListControl::IItemProvider*)#Missing ListViewColumnItemArranger::IColumnItemView from item provider."); - CHECK_ERROR(dataGridView != nullptr, L"GuiVirtualDataGrid::GuiVirtualDataGrid(IStyleController*, GuiListControl::IItemProvider*)#Missing IDataGridView from item provider."); - - SetViewToDefault(); - ColumnClicked.AttachMethod(this, &GuiVirtualDataGrid::OnColumnClicked); - SelectedCellChanged.SetAssociatedComposition(boundsComposition); - } - - GuiVirtualDataGrid::~GuiVirtualDataGrid() - { - } - - GuiListControl::IItemProvider* GuiVirtualDataGrid::GetItemProvider() - { - return GuiVirtualListView::GetItemProvider(); - } - - void GuiVirtualDataGrid::SetViewToDefault() - { - SetStyleAndArranger( - [](const Value&) { return new list::DefaultDataGridItemTemplate; }, - new list::ListViewColumnItemArranger - ); - } - - GridPos GuiVirtualDataGrid::GetSelectedCell() - { - return selectedCell; - } - - void GuiVirtualDataGrid::SetSelectedCell(const GridPos& value) - { - if (selectedCell == value) - { - return; - } - - bool validPos = 0 <= value.row && value.row < GetItemProvider()->Count() && 0 <= value.column && value.column < listViewItemView->GetColumnCount(); - StopEdit(true); - - if (validPos) - { - NotifySelectCell(value.row, value.column); - } - else - { - NotifySelectCell(-1, -1); - } - - if (validPos) - { - EnsureItemVisible(value.row); - ClearSelection(); - SetSelected(value.row, true); - StartEdit(value.row, value.column); - } - else - { - ClearSelection(); - } - } - } - } -} - -/*********************************************************************** -.\CONTROLS\LISTCONTROLPACKAGE\GUILISTVIEWITEMTEMPLATES.CPP -***********************************************************************/ - -namespace vl -{ - namespace presentation - { - namespace controls - { - using namespace elements; - using namespace compositions; - using namespace collections; - using namespace reflection::description; - - namespace list - { - -/*********************************************************************** -DefaultListViewItemTemplate -***********************************************************************/ - - DefaultListViewItemTemplate::DefaultListViewItemTemplate() - { - SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - } - - DefaultListViewItemTemplate::~DefaultListViewItemTemplate() - { - } - -/*********************************************************************** -BigIconListViewItemTemplate -***********************************************************************/ - - void BigIconListViewItemTemplate::OnInitialize() - { - DefaultListViewItemTemplate::OnInitialize(); - { - auto table = new GuiTableComposition; - AddChild(table); - table->SetRowsAndColumns(2, 3); - table->SetRowOption(0, GuiCellOption::MinSizeOption()); - table->SetRowOption(1, GuiCellOption::MinSizeOption()); - table->SetColumnOption(0, GuiCellOption::PercentageOption(0.5)); - table->SetColumnOption(1, GuiCellOption::MinSizeOption()); - table->SetColumnOption(2, GuiCellOption::PercentageOption(0.5)); - table->SetAlignmentToParent(Margin(0, 0, 0, 0)); - table->SetCellPadding(5); - { - auto cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(0, 1, 1, 1); - cell->SetPreferredMinSize(Size(32, 32)); - - image = GuiImageFrameElement::Create(); - image->SetStretch(true); - cell->SetOwnedElement(image); - } - { - auto cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetMinSizeLimitation(GuiGraphicsComposition::NoLimit); - cell->SetSite(1, 0, 1, 3); - cell->SetPreferredMinSize(Size(64, 40)); - - text = GuiSolidLabelElement::Create(); - text->SetAlignments(Alignment::Center, Alignment::Top); - text->SetWrapLine(true); - text->SetEllipse(true); - cell->SetOwnedElement(text); - } - } - - if (auto listView = dynamic_cast(listControl)) - { - auto itemIndex = GetIndex(); - if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - auto imageData = view->GetLargeImage(itemIndex); - if (imageData) - { - image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); - } - else - { - image->SetImage(nullptr); - } - text->SetText(view->GetText(itemIndex)); - text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); - } - } - - FontChanged.AttachMethod(this, &BigIconListViewItemTemplate::OnFontChanged); - - FontChanged.Execute(compositions::GuiEventArgs(this)); - } - - void BigIconListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - text->SetFont(GetFont()); - } - - BigIconListViewItemTemplate::BigIconListViewItemTemplate() - { - } - - BigIconListViewItemTemplate::~BigIconListViewItemTemplate() - { - } - -/*********************************************************************** -SmallIconListViewItemTemplate -***********************************************************************/ - - void SmallIconListViewItemTemplate::OnInitialize() - { - DefaultListViewItemTemplate::OnInitialize(); - { - auto table = new GuiTableComposition; - AddChild(table); - table->SetRowsAndColumns(3, 2); - table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); - table->SetRowOption(1, GuiCellOption::MinSizeOption()); - table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); - table->SetColumnOption(0, GuiCellOption::MinSizeOption()); - table->SetColumnOption(1, GuiCellOption::MinSizeOption()); - table->SetAlignmentToParent(Margin(0, 0, 0, 0)); - table->SetCellPadding(2); - { - GuiCellComposition* cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(1, 0, 1, 1); - cell->SetPreferredMinSize(Size(16, 16)); - - image = GuiImageFrameElement::Create(); - image->SetStretch(true); - cell->SetOwnedElement(image); - } - { - GuiCellComposition* cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(0, 1, 3, 1); - cell->SetPreferredMinSize(Size(192, 0)); - - text = GuiSolidLabelElement::Create(); - text->SetAlignments(Alignment::Left, Alignment::Center); - text->SetEllipse(true); - cell->SetOwnedElement(text); - } - } - - if (auto listView = dynamic_cast(listControl)) - { - auto itemIndex = GetIndex(); - if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - auto imageData = view->GetSmallImage(itemIndex); - if (imageData) - { - image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); - } - else - { - image->SetImage(nullptr); - } - text->SetText(view->GetText(itemIndex)); - text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); - } - } - - FontChanged.AttachMethod(this, &SmallIconListViewItemTemplate::OnFontChanged); - - FontChanged.Execute(compositions::GuiEventArgs(this)); - } - - void SmallIconListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - text->SetFont(GetFont()); - } - - SmallIconListViewItemTemplate::SmallIconListViewItemTemplate() - { - } - - SmallIconListViewItemTemplate::~SmallIconListViewItemTemplate() - { - } - -/*********************************************************************** -ListListViewItemTemplate -***********************************************************************/ - - void ListListViewItemTemplate::OnInitialize() - { - DefaultListViewItemTemplate::OnInitialize(); - { - auto table = new GuiTableComposition; - AddChild(table); - table->SetRowsAndColumns(3, 2); - table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); - table->SetRowOption(1, GuiCellOption::MinSizeOption()); - table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); - table->SetColumnOption(0, GuiCellOption::MinSizeOption()); - table->SetColumnOption(1, GuiCellOption::MinSizeOption()); - table->SetAlignmentToParent(Margin(0, 0, 0, 0)); - table->SetCellPadding(2); - { - auto cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(1, 0, 1, 1); - cell->SetPreferredMinSize(Size(16, 16)); - - image = GuiImageFrameElement::Create(); - image->SetStretch(true); - cell->SetOwnedElement(image); - } - { - auto cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(0, 1, 3, 1); - cell->SetMargin(Margin(0, 0, 16, 0)); - - text = GuiSolidLabelElement::Create(); - text->SetAlignments(Alignment::Left, Alignment::Center); - cell->SetOwnedElement(text); - } - } - - if (auto listView = dynamic_cast(listControl)) - { - auto itemIndex = GetIndex(); - if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - auto imageData = view->GetSmallImage(itemIndex); - if (imageData) - { - image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); - } - else - { - image->SetImage(nullptr); - } - text->SetText(view->GetText(itemIndex)); - text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); - } - } - - FontChanged.AttachMethod(this, &ListListViewItemTemplate::OnFontChanged); - - FontChanged.Execute(compositions::GuiEventArgs(this)); - } - - void ListListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - text->SetFont(GetFont()); - } - - ListListViewItemTemplate::ListListViewItemTemplate() - { - } - - ListListViewItemTemplate::~ListListViewItemTemplate() - { - } - -/*********************************************************************** -TileListViewItemTemplate -***********************************************************************/ - - elements::GuiSolidLabelElement* TileListViewItemTemplate::CreateTextElement(vint textRow) - { - auto cell = new GuiCellComposition; - textTable->AddChild(cell); - cell->SetSite(textRow + 1, 0, 1, 1); - - auto textElement = GuiSolidLabelElement::Create(); - textElement->SetAlignments(Alignment::Left, Alignment::Center); - textElement->SetEllipse(true); - cell->SetOwnedElement(textElement); - return textElement; - } - - void TileListViewItemTemplate::ResetTextTable(vint textRows) - { - textTable->SetRowsAndColumns(textRows + 2, 1); - textTable->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); - for (vint i = 0; iSetRowOption(i + 1, GuiCellOption::MinSizeOption()); - } - textTable->SetRowOption(textRows + 1, GuiCellOption::PercentageOption(0.5)); - textTable->SetColumnOption(0, GuiCellOption::PercentageOption(1.0)); - } - - void TileListViewItemTemplate::OnInitialize() - { - DefaultListViewItemTemplate::OnInitialize(); - { - auto table = new GuiTableComposition; - AddChild(table); - table->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - table->SetRowsAndColumns(3, 2); - table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); - table->SetRowOption(1, GuiCellOption::MinSizeOption()); - table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); - table->SetColumnOption(0, GuiCellOption::MinSizeOption()); - table->SetColumnOption(1, GuiCellOption::MinSizeOption()); - table->SetAlignmentToParent(Margin(0, 0, 0, 0)); - table->SetCellPadding(4); - { - auto cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(1, 0, 1, 1); - cell->SetPreferredMinSize(Size(32, 32)); - - image = GuiImageFrameElement::Create(); - image->SetStretch(true); - cell->SetOwnedElement(image); - } - { - auto cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(0, 1, 3, 1); - cell->SetPreferredMinSize(Size(224, 0)); - - textTable = new GuiTableComposition; - textTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - textTable->SetCellPadding(1); - ResetTextTable(1); - textTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); - cell->AddChild(textTable); - { - text = CreateTextElement(0); - } - } - } - - if (auto listView = dynamic_cast(listControl)) - { - auto itemIndex = GetIndex(); - if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - auto imageData = view->GetLargeImage(itemIndex); - if (imageData) - { - image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); - } - else - { - image->SetImage(nullptr); - } - text->SetText(view->GetText(itemIndex)); - text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); - - vint dataColumnCount = view->GetDataColumnCount(); - ResetTextTable(dataColumnCount + 1); - dataTexts.Resize(dataColumnCount); - for (vint i = 0; i < dataColumnCount; i++) - { - dataTexts[i] = CreateTextElement(i + 1); - dataTexts[i]->SetText(view->GetSubItem(itemIndex, view->GetDataColumn(i))); - dataTexts[i]->SetColor(listView->GetControlTemplateObject()->GetSecondaryTextColor()); - } - } - } - - FontChanged.AttachMethod(this, &TileListViewItemTemplate::OnFontChanged); - - FontChanged.Execute(compositions::GuiEventArgs(this)); - } - - void TileListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - text->SetFont(GetFont()); - if (auto view = dynamic_cast(listControl->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - vint dataColumnCount = view->GetDataColumnCount(); - for (vint i = 0; i < dataColumnCount; i++) - { - dataTexts[i]->SetFont(GetFont()); - } - } - } - - TileListViewItemTemplate::TileListViewItemTemplate() - { - } - - TileListViewItemTemplate::~TileListViewItemTemplate() - { - } - -/*********************************************************************** -InformationListViewItemTemplate -***********************************************************************/ - - void InformationListViewItemTemplate::OnInitialize() - { - DefaultListViewItemTemplate::OnInitialize(); - { - bottomLine = GuiSolidBackgroundElement::Create(); - bottomLineComposition = new GuiBoundsComposition; - bottomLineComposition->SetOwnedElement(bottomLine); - bottomLineComposition->SetAlignmentToParent(Margin(8, -1, 8, 0)); - bottomLineComposition->SetPreferredMinSize(Size(0, 1)); - AddChild(bottomLineComposition); - - auto table = new GuiTableComposition; - AddChild(table); - table->SetRowsAndColumns(3, 3); - table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); - table->SetRowOption(1, GuiCellOption::MinSizeOption()); - table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); - table->SetColumnOption(0, GuiCellOption::MinSizeOption()); - table->SetColumnOption(1, GuiCellOption::PercentageOption(1.0)); - table->SetColumnOption(2, GuiCellOption::MinSizeOption()); - table->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - table->SetAlignmentToParent(Margin(0, 0, 0, 0)); - table->SetCellPadding(4); - { - auto cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(1, 0, 1, 1); - cell->SetPreferredMinSize(Size(32, 32)); - - image = GuiImageFrameElement::Create(); - image->SetStretch(true); - cell->SetOwnedElement(image); - } - { - auto cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(0, 1, 3, 1); - - text = GuiSolidLabelElement::Create(); - text->SetEllipse(true); - cell->SetOwnedElement(text); - } - { - auto cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(0, 2, 3, 1); - cell->SetPreferredMinSize(Size(224, 0)); - - textTable = new GuiTableComposition; - textTable->SetCellPadding(4); - textTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - textTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); - cell->AddChild(textTable); - } - } - - if (auto listView = dynamic_cast(listControl)) - { - auto itemIndex = GetIndex(); - if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - auto imageData = view->GetLargeImage(itemIndex); - if (imageData) - { - image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); - } - else - { - image->SetImage(nullptr); - } - text->SetText(view->GetText(itemIndex)); - text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); - bottomLine->SetColor(listView->GetControlTemplateObject()->GetItemSeparatorColor()); - - vint dataColumnCount = view->GetDataColumnCount(); - columnTexts.Resize(dataColumnCount); - dataTexts.Resize(dataColumnCount); - - textTable->SetRowsAndColumns(dataColumnCount + 2, 1); - textTable->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); - for (vint i = 0; i < dataColumnCount; i++) - { - textTable->SetRowOption(i + 1, GuiCellOption::MinSizeOption()); - } - textTable->SetRowOption(dataColumnCount + 1, GuiCellOption::PercentageOption(0.5)); - textTable->SetColumnOption(0, GuiCellOption::PercentageOption(1.0)); - - for (vint i = 0; i < dataColumnCount; i++) - { - auto cell = new GuiCellComposition; - textTable->AddChild(cell); - cell->SetSite(i + 1, 0, 1, 1); - - auto dataTable = new GuiTableComposition; - dataTable->SetRowsAndColumns(1, 2); - dataTable->SetRowOption(0, GuiCellOption::MinSizeOption()); - dataTable->SetColumnOption(0, GuiCellOption::MinSizeOption()); - dataTable->SetColumnOption(1, GuiCellOption::PercentageOption(1.0)); - dataTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - dataTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); - cell->AddChild(dataTable); - { - auto cell = new GuiCellComposition; - dataTable->AddChild(cell); - cell->SetSite(0, 0, 1, 1); - - columnTexts[i] = GuiSolidLabelElement::Create(); - columnTexts[i]->SetText(view->GetColumnText(view->GetDataColumn(i) + 1) + L": "); - columnTexts[i]->SetColor(listView->GetControlTemplateObject()->GetSecondaryTextColor()); - cell->SetOwnedElement(columnTexts[i]); - } - { - auto cell = new GuiCellComposition; - dataTable->AddChild(cell); - cell->SetSite(0, 1, 1, 1); - - dataTexts[i]= GuiSolidLabelElement::Create(); - dataTexts[i]->SetEllipse(true); - dataTexts[i]->SetText(view->GetSubItem(itemIndex, view->GetDataColumn(i))); - dataTexts[i]->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); - cell->SetOwnedElement(dataTexts[i]); - } - } - } - } - - FontChanged.AttachMethod(this, &InformationListViewItemTemplate::OnFontChanged); - - FontChanged.Execute(compositions::GuiEventArgs(this)); - } - - void InformationListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - { - auto font = GetFont(); - font.size = (vint)(font.size * 1.2); - text->SetFont(font); - } - if (auto view = dynamic_cast(listControl->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - vint dataColumnCount = view->GetDataColumnCount(); - for (vint i = 0; i < dataColumnCount; i++) - { - columnTexts[i]->SetFont(GetFont()); - dataTexts[i]->SetFont(GetFont()); - } - } - } - - InformationListViewItemTemplate::InformationListViewItemTemplate() - { - } - - InformationListViewItemTemplate::~InformationListViewItemTemplate() - { - } - -/*********************************************************************** -DetailListViewItemTemplate -***********************************************************************/ - - void DetailListViewItemTemplate::OnInitialize() - { - DefaultListViewItemTemplate::OnInitialize(); - columnItemView = dynamic_cast(listControl->GetItemProvider()->RequestView(ListViewColumnItemArranger::IColumnItemView::Identifier)); - - { - textTable = new GuiTableComposition; - textTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); - textTable->SetRowsAndColumns(1, 1); - textTable->SetRowOption(0, GuiCellOption::MinSizeOption()); - textTable->SetColumnOption(0, GuiCellOption::AbsoluteOption(0)); - AddChild(textTable); - { - auto cell = new GuiCellComposition; - textTable->AddChild(cell); - cell->SetSite(0, 0, 1, 1); - - auto table = new GuiTableComposition; - cell->AddChild(table); - table->SetRowsAndColumns(3, 2); - table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); - table->SetRowOption(1, GuiCellOption::MinSizeOption()); - table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); - table->SetColumnOption(0, GuiCellOption::MinSizeOption()); - table->SetColumnOption(1, GuiCellOption::PercentageOption(1.0)); - table->SetAlignmentToParent(Margin(0, 0, 0, 0)); - table->SetCellPadding(2); - { - auto cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(1, 0, 1, 1); - cell->SetPreferredMinSize(Size(16, 16)); - - image = GuiImageFrameElement::Create(); - image->SetStretch(true); - cell->SetOwnedElement(image); - } - { - auto cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(0, 1, 3, 1); - cell->SetMargin(Margin(0, 0, 8, 0)); - - text = GuiSolidLabelElement::Create(); - text->SetAlignments(Alignment::Left, Alignment::Center); - text->SetEllipse(true); - cell->SetOwnedElement(text); - } - } - } - - if (auto listView = dynamic_cast(listControl)) - { - auto itemIndex = GetIndex(); - if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - auto imageData = view->GetSmallImage(itemIndex); - if (imageData) - { - image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); - } - else - { - image->SetImage(0); - } - text->SetText(view->GetText(itemIndex)); - text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); - - vint columnCount = view->GetColumnCount() - 1; - subItems.Resize(columnCount); - textTable->SetRowsAndColumns(1, columnCount + 1); - for (vint i = 0; i < columnCount; i++) - { - auto cell = new GuiCellComposition; - textTable->AddChild(cell); - cell->SetSite(0, i + 1, 1, 1); - cell->SetMargin(Margin(8, 0, 8, 0)); - - subItems[i] = GuiSolidLabelElement::Create(); - subItems[i]->SetAlignments(Alignment::Left, Alignment::Center); - subItems[i]->SetFont(text->GetFont()); - subItems[i]->SetEllipse(true); - subItems[i]->SetText(view->GetSubItem(itemIndex, i)); - subItems[i]->SetColor(listView->GetControlTemplateObject()->GetSecondaryTextColor()); - cell->SetOwnedElement(subItems[i]); - } - OnColumnChanged(); - } - } - - FontChanged.AttachMethod(this, &DetailListViewItemTemplate::OnFontChanged); - - FontChanged.Execute(compositions::GuiEventArgs(this)); - } - - void DetailListViewItemTemplate::OnColumnChanged() - { - if (auto view = dynamic_cast(listControl->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - if (columnItemView) - { - vint columnCount = view->GetColumnCount(); - if (columnCount>textTable->GetColumns()) - { - columnCount = textTable->GetColumns(); - } - for (vint i = 0; iSetColumnOption(i, GuiCellOption::AbsoluteOption(columnItemView->GetColumnSize(i))); - } - textTable->UpdateCellBounds(); - } - } - } - - void DetailListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - text->SetFont(GetFont()); - if (auto view = dynamic_cast(listControl->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - vint columnCount = view->GetColumnCount() - 1; - for (vint i = 0; i < columnCount; i++) - { - subItems[i]->SetFont(GetFont()); - } - } - } - - DetailListViewItemTemplate::DetailListViewItemTemplate() - { - } - - DetailListViewItemTemplate::~DetailListViewItemTemplate() - { - } - } - } - } -} - -/*********************************************************************** -.\CONTROLS\GUIAPPLICATION.CPP -***********************************************************************/ - -extern void GuiMain(); - -namespace vl -{ - namespace presentation - { - namespace controls - { - using namespace collections; - using namespace compositions; - using namespace theme; - using namespace description; - -/*********************************************************************** -GuiApplication -***********************************************************************/ - - void GuiApplication::InvokeClipboardNotify(compositions::GuiGraphicsComposition* composition, compositions::GuiEventArgs& arguments) - { - if(composition->HasEventReceiver()) - { - composition->GetEventReceiver()->clipboardNotify.Execute(arguments); - } - FOREACH(GuiGraphicsComposition*, subComposition, composition->Children()) - { - InvokeClipboardNotify(subComposition, arguments); - } - } - - void GuiApplication::LeftButtonDown(Point position) - { - OnMouseDown(position); - } - - void GuiApplication::LeftButtonUp(Point position) - { - } - - void GuiApplication::RightButtonDown(Point position) - { - OnMouseDown(position); - } - - void GuiApplication::RightButtonUp(Point position) - { - } - - void GuiApplication::ClipboardUpdated() - { - for(vint i=0;iGetNotifyEventArguments(); - windows[i]->ClipboardUpdated.Execute(arguments); - InvokeClipboardNotify(windows[i]->GetBoundsComposition(), arguments); - } - } - - GuiApplication::GuiApplication() - :mainWindow(0) - ,sharedTooltipOwnerWindow(0) - ,sharedTooltipOwner(0) - ,sharedTooltipControl(0) - ,sharedTooltipHovering(false) - ,sharedTooltipClosing(false) - { - GetCurrentController()->CallbackService()->InstallListener(this); - } - - GuiApplication::~GuiApplication() - { - if(sharedTooltipControl) - { - delete sharedTooltipControl; - sharedTooltipControl=0; - } - GetCurrentController()->CallbackService()->UninstallListener(this); - } - - void GuiApplication::RegisterWindow(GuiWindow* window) - { - windows.Add(window); - } - - void GuiApplication::UnregisterWindow(GuiWindow* window) - { - windows.Remove(window); - } - - void GuiApplication::RegisterPopupOpened(GuiPopup* popup) - { - vint index=openingPopups.IndexOf(popup); - if(index==-1) - { - openingPopups.Add(popup); - if(openingPopups.Count()==1) - { - GetCurrentController()->InputService()->StartHookMouse(); - } - } - } - - void GuiApplication::RegisterPopupClosed(GuiPopup* popup) - { - if(openingPopups.Remove(popup)) - { - if(openingPopups.Count()==0) - { - GetCurrentController()->InputService()->StopHookMouse(); - } - } - } - - void GuiApplication::OnMouseDown(Point location) - { - GuiWindow* window=GetWindow(location); - for(vint i=0;iMouseClickedOnOtherWindow(window); - } - } - } - - void GuiApplication::TooltipMouseEnter(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - sharedTooltipHovering=true; - } - - void GuiApplication::TooltipMouseLeave(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - sharedTooltipHovering=false; - if(sharedTooltipClosing) - { - CloseTooltip(); - } - } - - void GuiApplication::Run(GuiWindow* _mainWindow) - { - if(!mainWindow) - { - mainWindow=_mainWindow; - GetCurrentController()->WindowService()->Run(mainWindow->GetNativeWindow()); - mainWindow=0; - } - } - - GuiWindow* GuiApplication::GetMainWindow() - { - return mainWindow; - } - - const collections::List& GuiApplication::GetWindows() - { - return windows; - } - - GuiWindow* GuiApplication::GetWindow(Point location) - { - INativeWindow* nativeWindow=GetCurrentController()->WindowService()->GetWindow(location); - if(nativeWindow) - { - for(vint i=0;iGetNativeWindow()==nativeWindow) - { - return window; - } - } - } - return 0; - } - - void GuiApplication::ShowTooltip(GuiControl* owner, GuiControl* tooltip, vint preferredContentWidth, Point location) - { - GuiWindow* ownerWindow = dynamic_cast(owner->GetRelatedControlHost()); - if (sharedTooltipOwnerWindow != ownerWindow) - { - delete sharedTooltipControl; - sharedTooltipControl = 0; - } - - if(!sharedTooltipControl) - { - sharedTooltipControl = new GuiTooltip(theme::ThemeName::Tooltip); - if (ownerWindow) - { - if (auto tooltipStyle = ownerWindow->GetControlTemplateObject()->GetTooltipTemplate()) - { - sharedTooltipControl->SetControlTemplate(tooltipStyle); - } - } - sharedTooltipControl->GetBoundsComposition()->GetEventReceiver()->mouseEnter.AttachMethod(this, &GuiApplication::TooltipMouseEnter); - sharedTooltipControl->GetBoundsComposition()->GetEventReceiver()->mouseLeave.AttachMethod(this, &GuiApplication::TooltipMouseLeave); - } - - sharedTooltipHovering=false; - sharedTooltipClosing=false; - sharedTooltipOwnerWindow = ownerWindow; - sharedTooltipOwner=owner; - sharedTooltipControl->SetTemporaryContentControl(tooltip); - sharedTooltipControl->SetPreferredContentWidth(preferredContentWidth); - sharedTooltipControl->SetClientSize(Size(10, 10)); - sharedTooltipControl->ShowPopup(owner, location); - } - - void GuiApplication::CloseTooltip() - { - if(sharedTooltipControl) - { - if(sharedTooltipHovering) - { - sharedTooltipClosing=true; - } - else - { - sharedTooltipClosing=false; - sharedTooltipControl->Close(); - } - } - } - - GuiControl* GuiApplication::GetTooltipOwner() - { - if(!sharedTooltipControl) return 0; - if(!sharedTooltipControl->GetTemporaryContentControl()) return 0; - return sharedTooltipOwner; - } - - WString GuiApplication::GetExecutablePath() - { - return GetCurrentController()->GetExecutablePath(); - } - - WString GuiApplication::GetExecutableFolder() - { - WString path=GetExecutablePath(); - for(vint i=path.Length()-1;i>=0;i--) - { - if(path[i]==L'\\' || path[i]==L'/') - { - return path.Sub(0, i+1); - } - } - return L""; - } - - bool GuiApplication::IsInMainThread() - { - return GetCurrentController()->AsyncService()->IsInMainThread(); - } - - void GuiApplication::InvokeAsync(const Func& proc) - { - GetCurrentController()->AsyncService()->InvokeAsync(proc); - } - - void GuiApplication::InvokeInMainThread(const Func& proc) - { - GetCurrentController()->AsyncService()->InvokeInMainThread(proc); - } - - bool GuiApplication::InvokeInMainThreadAndWait(const Func& proc, vint milliseconds) - { - return GetCurrentController()->AsyncService()->InvokeInMainThreadAndWait(proc, milliseconds); - } - - Ptr GuiApplication::DelayExecute(const Func& proc, vint milliseconds) - { - return GetCurrentController()->AsyncService()->DelayExecute(proc, milliseconds); - } - - Ptr GuiApplication::DelayExecuteInMainThread(const Func& proc, vint milliseconds) - { - return GetCurrentController()->AsyncService()->DelayExecuteInMainThread(proc, milliseconds); - } - - void GuiApplication::RunGuiTask(const Func& proc) - { - if(IsInMainThread()) - { - return proc(); - } - else - { - InvokeInMainThreadAndWait([&proc]() - { - proc(); - }); - } - } - -/*********************************************************************** -GuiPluginManager -***********************************************************************/ - - class GuiPluginManager : public Object, public IGuiPluginManager - { - protected: - List> plugins; - bool loaded; - public: - GuiPluginManager() - :loaded(false) - { - } - - ~GuiPluginManager() - { - Unload(); - } - - void AddPlugin(Ptr plugin)override - { - CHECK_ERROR(!loaded, L"GuiPluginManager::AddPlugin(Ptr)#Load function has already been executed."); - auto name = plugin->GetName(); - if (name != L"") - { - FOREACH(Ptr, plugin, plugins) - { - CHECK_ERROR(plugin->GetName() != name, L"GuiPluginManager::AddPlugin(Ptr)#Duplicated plugin name."); - } - } - plugins.Add(plugin); - } - - void Load()override - { - CHECK_ERROR(!loaded, L"GuiPluginManager::AddPlugin(Ptr)#Load function has already been executed."); - loaded=true; - - SortedList loaded; - Group loading; - Dictionary> pluginsToLoad; - FOREACH(Ptr, plugin, plugins) - { - auto name = plugin->GetName(); - pluginsToLoad.Add(name, plugin); - List dependencies; - plugin->GetDependencies(dependencies); - FOREACH(WString, dependency, dependencies) - { - loading.Add(name, dependency); - } - } - - while (pluginsToLoad.Count() > 0) - { - vint count = pluginsToLoad.Count(); - { - FOREACH_INDEXER(WString, name, index, pluginsToLoad.Keys()) - { - if (!loading.Keys().Contains(name)) - { - for (vint i = loading.Count() - 1; i >= 0; i--) - { - loading.Remove(loading.Keys()[i], name); - } - loaded.Add(name); - - auto plugin = pluginsToLoad.Values()[index]; - pluginsToLoad.Remove(name); - plugin->Load(); - break; - } - } - } - if (count == pluginsToLoad.Count()) - { - WString message; - FOREACH(Ptr, plugin, pluginsToLoad.Values()) - { - message += L"Cannot load plugin \"" + plugin->GetName() + L"\" because part of its dependencies are not ready:"; - List dependencies; - plugin->GetDependencies(dependencies); - bool first = true; - FOREACH(WString, dependency, dependencies) - { - if (!loaded.Contains(dependency)) - { - message += L" \"" + dependency + L"\";"; - } - } - message += L"\r\n"; - } - throw Exception(message); - } - } - } - - void Unload()override - { - CHECK_ERROR(loaded, L"GuiPluginManager::AddPlugin(Ptr)#Load function has not been executed."); - loaded=false; - FOREACH(Ptr, plugin, plugins) - { - plugin->Unload(); - } - } - - bool IsLoaded()override - { - return loaded; - } - }; - -/*********************************************************************** -Helpers -***********************************************************************/ - - GuiApplication* application=0; - IGuiPluginManager* pluginManager=0; - - GuiApplication* GetApplication() - { - return application; - } - - IGuiPluginManager* GetPluginManager() - { - if(!pluginManager) - { - pluginManager=new GuiPluginManager; - } - return pluginManager; - } - - void DestroyPluginManager() - { - if(pluginManager) - { - delete pluginManager; - pluginManager=0; - } - } - -/*********************************************************************** -GuiApplicationMain -***********************************************************************/ - - class UIThreadAsyncScheduler :public Object, public IAsyncScheduler, public Description - { - public: - void Execute(const Func& callback)override - { - GetApplication()->InvokeInMainThread(callback); - } - - void ExecuteInBackground(const Func& callback)override - { - GetApplication()->InvokeAsync(callback); - } - - void DelayExecute(const Func& callback, vint milliseconds)override - { - GetApplication()->DelayExecuteInMainThread(callback, milliseconds); - } - }; - - class OtherThreadAsyncScheduler :public Object, public IAsyncScheduler, public Description - { - public: - void Execute(const Func& callback)override - { - GetApplication()->InvokeAsync(callback); - } - - void ExecuteInBackground(const Func& callback)override - { - GetApplication()->InvokeAsync(callback); - } - - void DelayExecute(const Func& callback, vint milliseconds)override - { - GetApplication()->DelayExecute(callback, milliseconds); - } - }; - - void GuiApplicationInitialize() - { - GetCurrentController()->InputService()->StartTimer(); - theme::InitializeTheme(); - -#ifndef VCZH_DEBUG_NO_REFLECTION - GetGlobalTypeManager()->Load(); -#endif - GetPluginManager()->Load(); - - { - GuiApplication app; - application = &app; - IAsyncScheduler::RegisterSchedulerForCurrentThread(new UIThreadAsyncScheduler); - IAsyncScheduler::RegisterDefaultScheduler(new OtherThreadAsyncScheduler); - GuiMain(); - IAsyncScheduler::UnregisterDefaultScheduler(); - IAsyncScheduler::UnregisterSchedulerForCurrentThread(); - application = nullptr; - } - - DestroyPluginManager(); - theme::FinalizeTheme(); - ThreadLocalStorage::DisposeStorages(); - FinalizeGlobalStorage(); -#ifndef VCZH_DEBUG_NO_REFLECTION - DestroyGlobalTypeManager(); -#endif - } - } - } -} - -void GuiApplicationMain() -{ - vl::presentation::controls::GuiApplicationInitialize(); -} - -/*********************************************************************** -.\CONTROLS\GUIBASICCONTROLS.CPP -***********************************************************************/ - -namespace vl -{ - namespace presentation - { - namespace controls - { - using namespace elements; - using namespace compositions; - using namespace collections; - using namespace reflection::description; - -/*********************************************************************** -GuiControl -***********************************************************************/ - - void GuiControl::BeforeControlTemplateUninstalled() - { - } - - void GuiControl::AfterControlTemplateInstalled(bool initialize) - { - controlTemplateObject->SetText(text); - controlTemplateObject->SetFont(font); - controlTemplateObject->SetVisuallyEnabled(isVisuallyEnabled); - controlTemplateObject->SetFocusableComposition(focusableComposition); - } - - void GuiControl::CheckAndStoreControlTemplate(templates::GuiControlTemplate* value) - { - controlTemplateObject = value; - } - - void GuiControl::EnsureControlTemplateExists() - { - if (!controlTemplateObject) - { - RebuildControlTemplate(); - } - } - - void GuiControl::RebuildControlTemplate() - { - bool initialize = controlTemplateObject == nullptr; - if (controlTemplateObject) - { - BeforeControlTemplateUninstalled(); - containerComposition->GetParent()->RemoveChild(containerComposition); - boundsComposition->AddChild(containerComposition); - SafeDeleteComposition(controlTemplateObject); - controlTemplateObject = nullptr; - } - - if (controlTemplate) - { - CheckAndStoreControlTemplate(controlTemplate({})); - } - else - { - CheckAndStoreControlTemplate(theme::GetCurrentTheme()->CreateStyle(controlThemeName)({})); - } - - if (controlTemplateObject) - { - controlTemplateObject->Initialize(); - controlTemplateObject->SetAlignmentToParent(Margin(0, 0, 0, 0)); - - containerComposition->GetParent()->RemoveChild(containerComposition); - boundsComposition->AddChild(controlTemplateObject); - controlTemplateObject->GetContainerComposition()->AddChild(containerComposition); - AfterControlTemplateInstalled(initialize); - } - } - - void GuiControl::OnChildInserted(GuiControl* control) - { - GuiControl* oldParent=control->parent; - children.Add(control); - control->parent=this; - control->OnParentChanged(oldParent, control->parent); - control->UpdateVisuallyEnabled(); - } - - void GuiControl::OnChildRemoved(GuiControl* control) - { - GuiControl* oldParent=control->parent; - control->parent=0; - children.Remove(control); - control->OnParentChanged(oldParent, control->parent); - } - - void GuiControl::OnParentChanged(GuiControl* oldParent, GuiControl* newParent) - { - OnParentLineChanged(); - } - - void GuiControl::OnParentLineChanged() - { - for(vint i=0;iOnParentLineChanged(); - } - } - - void GuiControl::OnRenderTargetChanged(elements::IGuiGraphicsRenderTarget* renderTarget) - { - RenderTargetChanged.Execute(GetNotifyEventArguments()); - } - - void GuiControl::OnBeforeReleaseGraphicsHost() - { - for(vint i=0;iOnBeforeReleaseGraphicsHost(); - } - } - - void GuiControl::UpdateVisuallyEnabled() - { - bool newValue = isEnabled && (parent == 0 ? true : parent->GetVisuallyEnabled()); - if (isVisuallyEnabled != newValue) - { - isVisuallyEnabled = newValue; - if (controlTemplateObject) - { - controlTemplateObject->SetVisuallyEnabled(isVisuallyEnabled); - } - VisuallyEnabledChanged.Execute(GetNotifyEventArguments()); - - for (vint i = 0; i < children.Count(); i++) - { - children[i]->UpdateVisuallyEnabled(); - } - } - } - - void GuiControl::SetFocusableComposition(compositions::GuiGraphicsComposition* value) - { - if (focusableComposition != value) - { - focusableComposition = value; - if (controlTemplateObject) - { - controlTemplateObject->SetFocusableComposition(focusableComposition); - } - } - } - - bool GuiControl::IsAltEnabled() - { - GuiControl* control = this; - while (control) - { - if (!control->GetVisible() || !control->GetEnabled()) - { - return false; - } - control = control->GetParent(); - } - - return true; - } - - bool GuiControl::IsAltAvailable() - { - return focusableComposition != 0 && alt != L""; - } - - compositions::GuiGraphicsComposition* GuiControl::GetAltComposition() - { - return boundsComposition; - } - - compositions::IGuiAltActionHost* GuiControl::GetActivatingAltHost() - { - return activatingAltHost; - } - - void GuiControl::OnActiveAlt() - { - SetFocus(); - } - - bool GuiControl::SharedPtrDestructorProc(DescriptableObject* obj, bool forceDisposing) - { - GuiControl* value=dynamic_cast(obj); - if(value->GetBoundsComposition()->GetParent()) - { - if (!forceDisposing) return false; - } - SafeDeleteControl(value); - return true; - } - - GuiControl::GuiControl(theme::ThemeName themeName) - :controlThemeName(themeName) - { - { - boundsComposition = new GuiBoundsComposition; - boundsComposition->SetAssociatedControl(this); - boundsComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - - containerComposition = new GuiBoundsComposition; - containerComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - containerComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); - - boundsComposition->AddChild(containerComposition); - } - { - ControlTemplateChanged.SetAssociatedComposition(boundsComposition); - RenderTargetChanged.SetAssociatedComposition(boundsComposition); - VisibleChanged.SetAssociatedComposition(boundsComposition); - EnabledChanged.SetAssociatedComposition(boundsComposition); - VisuallyEnabledChanged.SetAssociatedComposition(boundsComposition); - AltChanged.SetAssociatedComposition(boundsComposition); - TextChanged.SetAssociatedComposition(boundsComposition); - FontChanged.SetAssociatedComposition(boundsComposition); - } - font = GetCurrentController()->ResourceService()->GetDefaultFont(); - sharedPtrDestructorProc = &GuiControl::SharedPtrDestructorProc; - } - - GuiControl::~GuiControl() - { - // prevent a root bounds composition from notifying its dead controls - if (!parent) - { - NotifyFinalizeInstance(boundsComposition); - } - - if (tooltipControl) - { - // the only legal parent is the GuiApplication::sharedTooltipWindow - if (tooltipControl->GetBoundsComposition()->GetParent()) - { - tooltipControl->GetBoundsComposition()->GetParent()->RemoveChild(tooltipControl->GetBoundsComposition()); - } - delete tooltipControl; - } - - for (vint i = 0; i < children.Count(); i++) - { - delete children[i]; - } - children.Clear(); - - // let the root control of a control tree delete the whole composition tree - if (!parent) - { - delete boundsComposition; - } - } - - compositions::GuiEventArgs GuiControl::GetNotifyEventArguments() - { - return GuiEventArgs(boundsComposition); - } - - GuiControl::ControlTemplatePropertyType GuiControl::GetControlTemplate() - { - return controlTemplate; - } - - void GuiControl::SetControlTemplate(const ControlTemplatePropertyType& value) - { - controlTemplate = value; - RebuildControlTemplate(); - ControlTemplateChanged.Execute(GetNotifyEventArguments()); - } - - templates::GuiControlTemplate* GuiControl::GetControlTemplateObject() - { - EnsureControlTemplateExists(); - return controlTemplateObject; - } - - compositions::GuiBoundsComposition* GuiControl::GetBoundsComposition() - { - EnsureControlTemplateExists(); - return boundsComposition; - } - - compositions::GuiGraphicsComposition* GuiControl::GetContainerComposition() - { - EnsureControlTemplateExists(); - return containerComposition; - } - - compositions::GuiGraphicsComposition* GuiControl::GetFocusableComposition() - { - EnsureControlTemplateExists(); - return focusableComposition; - } - - GuiControl* GuiControl::GetParent() - { - return parent; - } - - vint GuiControl::GetChildrenCount() - { - return children.Count(); - } - - GuiControl* GuiControl::GetChild(vint index) - { - return children[index]; - } - - bool GuiControl::AddChild(GuiControl* control) - { - return GetContainerComposition()->AddChild(control->GetBoundsComposition()); - } - - bool GuiControl::HasChild(GuiControl* control) - { - return children.Contains(control); - } - - GuiControlHost* GuiControl::GetRelatedControlHost() - { - return parent?parent->GetRelatedControlHost():0; - } - - bool GuiControl::GetVisuallyEnabled() - { - return isVisuallyEnabled; - } - - bool GuiControl::GetEnabled() - { - return isEnabled; - } - - void GuiControl::SetEnabled(bool value) - { - if(isEnabled!=value) - { - isEnabled=value; - EnabledChanged.Execute(GetNotifyEventArguments()); - UpdateVisuallyEnabled(); - } - } - - bool GuiControl::GetVisible() - { - return isVisible; - } - - void GuiControl::SetVisible(bool value) - { - boundsComposition->SetVisible(value); - if(isVisible!=value) - { - isVisible=value; - VisibleChanged.Execute(GetNotifyEventArguments()); - } - } - - const WString& GuiControl::GetAlt() - { - return alt; - } - - bool GuiControl::SetAlt(const WString& value) - { - if (!IGuiAltAction::IsLegalAlt(value)) return false; - if (alt != value) - { - alt = value; - AltChanged.Execute(GetNotifyEventArguments()); - } - return true; - } - - void GuiControl::SetActivatingAltHost(compositions::IGuiAltActionHost* host) - { - activatingAltHost = host; - } - - const WString& GuiControl::GetText() - { - return text; - } - - void GuiControl::SetText(const WString& value) - { - if (text != value) - { - text = value; - if (controlTemplateObject) - { - controlTemplateObject->SetText(text); - } - TextChanged.Execute(GetNotifyEventArguments()); - } - } - - const FontProperties& GuiControl::GetFont() - { - return font; - } - - void GuiControl::SetFont(const FontProperties& value) - { - if (font != value) - { - font = value; - if (controlTemplateObject) - { - controlTemplateObject->SetFont(font); - } - FontChanged.Execute(GetNotifyEventArguments()); - } - } - - void GuiControl::SetFocus() - { - if(focusableComposition) - { - GuiGraphicsHost* host=focusableComposition->GetRelatedGraphicsHost(); - if(host) - { - host->SetFocus(focusableComposition); - } - } - } - - description::Value GuiControl::GetTag() - { - return tag; - } - - void GuiControl::SetTag(const description::Value& value) - { - tag=value; - } - - GuiControl* GuiControl::GetTooltipControl() - { - return tooltipControl; - } - - GuiControl* GuiControl::SetTooltipControl(GuiControl* value) - { - GuiControl* oldTooltipControl=tooltipControl; - tooltipControl=value; - return oldTooltipControl; - } - - vint GuiControl::GetTooltipWidth() - { - return tooltipWidth; - } - - void GuiControl::SetTooltipWidth(vint value) - { - tooltipWidth=value; - } - - bool GuiControl::DisplayTooltip(Point location) - { - if(!tooltipControl) return false; - GetApplication()->ShowTooltip(this, tooltipControl, tooltipWidth, location); - return true; - } - - void GuiControl::CloseTooltip() - { - if(GetApplication()->GetTooltipOwner()==this) - { - GetApplication()->CloseTooltip(); - } - } - - IDescriptable* GuiControl::QueryService(const WString& identifier) - { - if (identifier == IGuiAltAction::Identifier) - { - return (IGuiAltAction*)this; - } - else if (identifier == IGuiAltActionContainer::Identifier) - { - return 0; - } - else if(parent) - { - return parent->QueryService(identifier); - } - else - { - return 0; - } - } - -/*********************************************************************** -GuiCustomControl -***********************************************************************/ - - GuiCustomControl::GuiCustomControl(theme::ThemeName themeName) - :GuiControl(themeName) - { - } - - GuiCustomControl::~GuiCustomControl() - { - FinalizeAggregation(); - FinalizeInstanceRecursively(this); - } - } - } -} - -/*********************************************************************** -.\CONTROLS\LISTCONTROLPACKAGE\GUIDATAGRIDEXTENSIONS.CPP -***********************************************************************/ - -namespace vl -{ - namespace presentation - { - namespace controls - { - namespace list - { - using namespace compositions; - using namespace elements; - using namespace theme; - using namespace templates; - -/*********************************************************************** -DataVisualizerBase -***********************************************************************/ - - DataVisualizerBase::DataVisualizerBase() - { - } - - DataVisualizerBase::~DataVisualizerBase() - { - if (visualizerTemplate) - { - SafeDeleteComposition(visualizerTemplate); - } - } - - IDataVisualizerFactory* DataVisualizerBase::GetFactory() - { - return factory; - } - - templates::GuiGridVisualizerTemplate* DataVisualizerBase::GetTemplate() - { - return visualizerTemplate; - } - - void DataVisualizerBase::NotifyDeletedTemplate() - { - visualizerTemplate = nullptr; - } - - void DataVisualizerBase::BeforeVisualizeCell(GuiListControl::IItemProvider* itemProvider, vint row, vint column) - { - if (auto listViewItemView = dynamic_cast(dataGridContext->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - auto style = dataGridContext->GetListViewControlTemplate(); - visualizerTemplate->SetPrimaryTextColor(style->GetPrimaryTextColor()); - visualizerTemplate->SetSecondaryTextColor(style->GetSecondaryTextColor()); - visualizerTemplate->SetItemSeparatorColor(style->GetItemSeparatorColor()); - - visualizerTemplate->SetLargeImage(listViewItemView->GetLargeImage(row)); - visualizerTemplate->SetSmallImage(listViewItemView->GetSmallImage(row)); - visualizerTemplate->SetText(column == 0 ? listViewItemView->GetText(row) : listViewItemView->GetSubItem(row, column - 1)); - } - if (auto dataGridView = dynamic_cast(dataGridContext->GetItemProvider()->RequestView(IDataGridView::Identifier))) - { - visualizerTemplate->SetRowValue(itemProvider->GetBindingValue(row)); - visualizerTemplate->SetCellValue(dataGridView->GetBindingCellValue(row, column)); - } - } - - void DataVisualizerBase::SetSelected(bool value) - { - if (visualizerTemplate) - { - visualizerTemplate->SetSelected(value); - } - } - -/*********************************************************************** -DataVisualizerFactory -***********************************************************************/ - - DataVisualizerFactory::ItemTemplate* DataVisualizerFactory::CreateItemTemplate(controls::list::IDataGridContext* dataGridContext) - { - ItemTemplate* itemTemplate = templateFactory(dataGridContext->GetViewModelContext()); - CHECK_ERROR(itemTemplate, L"DataVisualizerFactory::CreateItemTemplate(IDataGridContext*)#An instance of GuiGridEditorTemplate is expected."); - if (decoratedFactory) - { - auto childTemplate = decoratedFactory->CreateItemTemplate(dataGridContext); - childTemplate->SetAlignmentToParent(Margin(0, 0, 0, 0)); - itemTemplate->GetContainerComposition()->AddChild(childTemplate); - -#define FORWARD_EVENT(NAME)\ - itemTemplate->NAME##Changed.AttachLambda([=](GuiGraphicsComposition* sender, GuiEventArgs& arguments)\ - {\ - childTemplate->Set##NAME(itemTemplate->Get##NAME());\ - });\ - -#define FORWARD_EVENT_IMPL(CLASS, TYPE, NAME) FORWARD_EVENT(NAME) - - GuiTemplate_PROPERTIES(FORWARD_EVENT_IMPL) - GuiControlTemplate_PROPERTIES(FORWARD_EVENT_IMPL) - GuiGridCellTemplate_PROPERTIES(FORWARD_EVENT_IMPL) - GuiGridVisualizerTemplate_PROPERTIES(FORWARD_EVENT_IMPL) - -#undef FORWARD_EVENT_IMPL -#undef FORWARD_EVENT - } - return itemTemplate; - } - - DataVisualizerFactory::DataVisualizerFactory(TemplateProperty _templateFactory, Ptr _decoratedFactory) - :templateFactory(_templateFactory) - , decoratedFactory(_decoratedFactory) - { - } - - DataVisualizerFactory::~DataVisualizerFactory() - { - } - - Ptr DataVisualizerFactory::CreateVisualizer(controls::list::IDataGridContext* dataGridContext) - { - auto dataVisualizer = MakePtr(); - dataVisualizer->factory = this; - dataVisualizer->dataGridContext = dataGridContext; - dataVisualizer->visualizerTemplate = CreateItemTemplate(dataGridContext); - - return dataVisualizer; - } - -/*********************************************************************** -DataEditorBase -***********************************************************************/ - - void DataEditorBase::OnCellValueChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - dataGridContext->RequestSaveData(); - } - - DataEditorBase::DataEditorBase() - { - } - - DataEditorBase::~DataEditorBase() - { - if (editorTemplate) - { - SafeDeleteComposition(editorTemplate); - } - } - - IDataEditorFactory* DataEditorBase::GetFactory() - { - return factory; - } - - templates::GuiGridEditorTemplate* DataEditorBase::GetTemplate() - { - return editorTemplate; - } - - void DataEditorBase::NotifyDeletedTemplate() - { - editorTemplate = nullptr; - } - - void DataEditorBase::BeforeEditCell(GuiListControl::IItemProvider* itemProvider, vint row, vint column) - { - if (auto listViewItemView = dynamic_cast(dataGridContext->GetItemProvider()->RequestView(IListViewItemView::Identifier))) - { - auto style = dataGridContext->GetListViewControlTemplate(); - editorTemplate->SetPrimaryTextColor(style->GetPrimaryTextColor()); - editorTemplate->SetSecondaryTextColor(style->GetSecondaryTextColor()); - editorTemplate->SetItemSeparatorColor(style->GetItemSeparatorColor()); - - editorTemplate->SetLargeImage(listViewItemView->GetLargeImage(row)); - editorTemplate->SetSmallImage(listViewItemView->GetSmallImage(row)); - editorTemplate->SetText(column == 0 ? listViewItemView->GetText(row) : listViewItemView->GetSubItem(row, column - 1)); - } - if (auto dataGridView = dynamic_cast(dataGridContext->GetItemProvider()->RequestView(IDataGridView::Identifier))) - { - editorTemplate->SetRowValue(itemProvider->GetBindingValue(row)); - editorTemplate->SetCellValue(dataGridView->GetBindingCellValue(row, column)); - } - editorTemplate->CellValueChanged.AttachMethod(this, &DataEditorBase::OnCellValueChanged); - } - - bool DataEditorBase::GetCellValueSaved() - { - if (editorTemplate) - { - return editorTemplate->GetCellValueSaved(); - } - return true; - } - -/*********************************************************************** -DataEditorFactory -***********************************************************************/ - - DataEditorFactory::DataEditorFactory(TemplateProperty _templateFactory) - :templateFactory(_templateFactory) - { - } - - DataEditorFactory::~DataEditorFactory() - { - } - - Ptr DataEditorFactory::CreateEditor(controls::list::IDataGridContext* dataGridContext) - { - auto editor = MakePtr(); - editor->factory = this; - editor->dataGridContext = dataGridContext; - - ItemTemplate* itemTemplate = templateFactory(dataGridContext->GetViewModelContext()); - CHECK_ERROR(itemTemplate, L"DataEditorFactory::CreateEditor(IDataGridContext*)#An instance of GuiGridEditorTemplate is expected."); - editor->editorTemplate = itemTemplate; - return editor; - } - -/*********************************************************************** -MainColumnVisualizerTemplate -***********************************************************************/ - - void MainColumnVisualizerTemplate::OnTextChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - text->SetText(GetText()); - } - - void MainColumnVisualizerTemplate::OnFontChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - text->SetFont(GetFont()); - } - - void MainColumnVisualizerTemplate::OnTextColorChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - text->SetColor(GetPrimaryTextColor()); - } - - void MainColumnVisualizerTemplate::OnSmallImageChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - auto imageData = GetSmallImage(); - if (imageData) - { - image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); - } - else - { - image->SetImage(nullptr); - } - } - - MainColumnVisualizerTemplate::MainColumnVisualizerTemplate() - { - GuiTableComposition* table = new GuiTableComposition; - table->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - table->SetRowsAndColumns(3, 2); - table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); - table->SetRowOption(1, GuiCellOption::MinSizeOption()); - table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); - table->SetColumnOption(0, GuiCellOption::MinSizeOption()); - table->SetColumnOption(1, GuiCellOption::PercentageOption(1.0)); - table->SetCellPadding(2); - { - GuiCellComposition* cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(1, 0, 1, 1); - cell->SetPreferredMinSize(Size(16, 16)); - - image = GuiImageFrameElement::Create(); - image->SetStretch(true); - cell->SetOwnedElement(image); - } - { - GuiCellComposition* cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(0, 1, 3, 1); - cell->SetMargin(Margin(0, 0, 8, 0)); - - text = GuiSolidLabelElement::Create(); - text->SetAlignments(Alignment::Left, Alignment::Center); - text->SetEllipse(true); - cell->SetOwnedElement(text); - } - table->SetAlignmentToParent(Margin(0, 0, 0, 0)); - - SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - AddChild(table); - - TextChanged.AttachMethod(this, &MainColumnVisualizerTemplate::OnTextChanged); - FontChanged.AttachMethod(this, &MainColumnVisualizerTemplate::OnFontChanged); - PrimaryTextColorChanged.AttachMethod(this, &MainColumnVisualizerTemplate::OnTextColorChanged); - SmallImageChanged.AttachMethod(this, &MainColumnVisualizerTemplate::OnSmallImageChanged); - - TextChanged.Execute(compositions::GuiEventArgs(this)); - FontChanged.Execute(compositions::GuiEventArgs(this)); - PrimaryTextColorChanged.Execute(compositions::GuiEventArgs(this)); - SmallImageChanged.Execute(compositions::GuiEventArgs(this)); - } - - MainColumnVisualizerTemplate::~MainColumnVisualizerTemplate() - { - } - -/*********************************************************************** -SubColumnVisualizerTemplate -***********************************************************************/ - - void SubColumnVisualizerTemplate::OnTextChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - text->SetText(GetText()); - } - - void SubColumnVisualizerTemplate::OnFontChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - text->SetFont(GetFont()); - } - - void SubColumnVisualizerTemplate::OnTextColorChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - text->SetColor(GetSecondaryTextColor()); - } - - void SubColumnVisualizerTemplate::Initialize(bool fixTextColor) - { - text = GuiSolidLabelElement::Create(); - text->SetVerticalAlignment(Alignment::Center); - - SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - SetMargin(Margin(8, 0, 8, 0)); - SetOwnedElement(text); - - TextChanged.AttachMethod(this, &SubColumnVisualizerTemplate::OnTextChanged); - FontChanged.AttachMethod(this, &SubColumnVisualizerTemplate::OnFontChanged); - if (!fixTextColor) - { - SecondaryTextColorChanged.AttachMethod(this, &SubColumnVisualizerTemplate::OnTextColorChanged); - } - - TextChanged.Execute(compositions::GuiEventArgs(this)); - FontChanged.Execute(compositions::GuiEventArgs(this)); - if (!fixTextColor) - { - SecondaryTextColorChanged.Execute(compositions::GuiEventArgs(this)); - } - } - - SubColumnVisualizerTemplate::SubColumnVisualizerTemplate(bool fixTextColor) - { - Initialize(fixTextColor); - } - - SubColumnVisualizerTemplate::SubColumnVisualizerTemplate() - { - Initialize(false); - } - - SubColumnVisualizerTemplate::~SubColumnVisualizerTemplate() - { - } - -/*********************************************************************** -HyperlinkVisualizerTemplate -***********************************************************************/ - - void HyperlinkVisualizerTemplate::label_MouseEnter(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - FontProperties font = text->GetFont(); - font.underline = true; - text->SetFont(font); - } - - void HyperlinkVisualizerTemplate::label_MouseLeave(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - FontProperties font = text->GetFont(); - font.underline = false; - text->SetFont(font); - } - - HyperlinkVisualizerTemplate::HyperlinkVisualizerTemplate() - :SubColumnVisualizerTemplate(true) - { - text->SetColor(Color(0, 0, 255)); - text->SetEllipse(true); - GetEventReceiver()->mouseEnter.AttachMethod(this, &HyperlinkVisualizerTemplate::label_MouseEnter); - GetEventReceiver()->mouseLeave.AttachMethod(this, &HyperlinkVisualizerTemplate::label_MouseLeave); - SetAssociatedCursor(GetCurrentController()->ResourceService()->GetSystemCursor(INativeCursor::Hand)); - } - - HyperlinkVisualizerTemplate::~HyperlinkVisualizerTemplate() - { - } - -/*********************************************************************** -CellBorderVisualizerTemplate -***********************************************************************/ - - void CellBorderVisualizerTemplate::OnItemSeparatorColorChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - border1->SetColor(GetItemSeparatorColor()); - border2->SetColor(GetItemSeparatorColor()); - } - - CellBorderVisualizerTemplate::CellBorderVisualizerTemplate() - { - GuiBoundsComposition* bounds1 = nullptr; - GuiBoundsComposition* bounds2 = nullptr; - { - border1 = GuiSolidBorderElement::Create(); - - bounds1 = new GuiBoundsComposition; - bounds1->SetOwnedElement(border1); - bounds1->SetAlignmentToParent(Margin(-1, 0, 0, 0)); - } - { - border2 = GuiSolidBorderElement::Create(); - - bounds2 = new GuiBoundsComposition; - bounds2->SetOwnedElement(border2); - bounds2->SetAlignmentToParent(Margin(0, -1, 0, 0)); - } - - SetAlignmentToParent(Margin(0, 0, 1, 1)); - SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - AddChild(bounds1); - AddChild(bounds2); - - ItemSeparatorColorChanged.AttachMethod(this, &CellBorderVisualizerTemplate::OnItemSeparatorColorChanged); - - ItemSeparatorColorChanged.Execute(compositions::GuiEventArgs(this)); - } - - CellBorderVisualizerTemplate::~CellBorderVisualizerTemplate() - { - } - } - } - } -} - -/*********************************************************************** -.\CONTROLS\LISTCONTROLPACKAGE\GUILISTCONTROLITEMARRANGERS.CPP -***********************************************************************/ - -namespace vl -{ - namespace presentation - { - namespace controls - { - using namespace collections; - using namespace elements; - using namespace compositions; - - namespace list - { - -/*********************************************************************** -RangedItemArrangerBase -***********************************************************************/ - - void RangedItemArrangerBase::InvalidateAdoptedSize() - { - if (listControl) - { - listControl->AdoptedSizeInvalidated.Execute(listControl->GetNotifyEventArguments()); - } - } - - vint RangedItemArrangerBase::CalculateAdoptedSize(vint expectedSize, vint count, vint itemSize) - { - vint visibleCount = expectedSize / itemSize; - if (count < visibleCount) - { - visibleCount = count; - } - else if (count > visibleCount) - { - vint deltaA = expectedSize - count * itemSize; - vint deltaB = itemSize - deltaA; - if (deltaB < deltaA) - { - visibleCount++; - } - } - return visibleCount * itemSize; - } - - RangedItemArrangerBase::ItemStyleRecord RangedItemArrangerBase::CreateStyle(vint index) - { - GuiSelectableButton* backgroundButton = nullptr; - if (listControl->GetDisplayItemBackground()) - { - backgroundButton = new GuiSelectableButton(theme::ThemeName::ListItemBackground); - if (auto style = listControl->GetControlTemplateObject()->GetBackgroundTemplate()) - { - backgroundButton->SetControlTemplate(style); - } - backgroundButton->SetAutoSelection(false); - } - - auto itemStyle = callback->RequestItem(index, backgroundButton->GetBoundsComposition()); - if (backgroundButton) - { - itemStyle->SetAlignmentToParent(Margin(0, 0, 0, 0)); - itemStyle->SelectedChanged.AttachLambda([=](GuiGraphicsComposition* sender, GuiEventArgs& arguments) - { - backgroundButton->SetSelected(itemStyle->GetSelected()); - }); - backgroundButton->GetContainerComposition()->AddChild(itemStyle); - } - return { itemStyle, backgroundButton }; - } - - void RangedItemArrangerBase::DeleteStyle(ItemStyleRecord style) - { - callback->ReleaseItem(style.key); - if (style.value) - { - SafeDeleteControl(style.value); - } - } - - compositions::GuiBoundsComposition* RangedItemArrangerBase::GetStyleBounds(ItemStyleRecord style) - { - return style.value ? style.value->GetBoundsComposition() : style.key; - } - - void RangedItemArrangerBase::ClearStyles() - { - startIndex = 0; - if (callback) - { - for (vint i = 0; i < visibleStyles.Count(); i++) - { - DeleteStyle(visibleStyles[i]); - } - } - visibleStyles.Clear(); - viewBounds = Rect(0, 0, 0, 0); - InvalidateItemSizeCache(); - InvalidateAdoptedSize(); - } - - void RangedItemArrangerBase::OnViewChangedInternal(Rect oldBounds, Rect newBounds) - { - vint endIndex = startIndex + visibleStyles.Count() - 1; - vint newStartIndex = 0; - vint itemCount = itemProvider->Count(); - BeginPlaceItem(true, newBounds, newStartIndex); - if (newStartIndex < 0) newStartIndex = 0; - - StyleList newVisibleStyles; - for (vint i = newStartIndex; i < itemCount; i++) - { - auto style - = startIndex <= i && i <= endIndex - ? visibleStyles[i - startIndex] - : CreateStyle(i) - ; - newVisibleStyles.Add(style); - - Rect bounds; - Margin alignmentToParent; - PlaceItem(true, i, style, newBounds, bounds, alignmentToParent); - if (IsItemOutOfViewBounds(i, style, bounds, newBounds)) - { - break; - } - - bounds.x1 -= newBounds.x1; - bounds.x2 -= newBounds.x1; - bounds.y1 -= newBounds.y1; - bounds.y2 -= newBounds.y1; - } - - vint newEndIndex = newStartIndex + newVisibleStyles.Count() - 1; - for (vint i = 0; i < visibleStyles.Count(); i++) - { - vint index = startIndex + i; - if (index < newStartIndex || index > newEndIndex) - { - DeleteStyle(visibleStyles[i]); - } - } - CopyFrom(visibleStyles, newVisibleStyles); - - if (EndPlaceItem(true, newBounds, newStartIndex)) - { - callback->OnTotalSizeChanged(); - InvalidateAdoptedSize(); - } - startIndex = newStartIndex; - } - - void RangedItemArrangerBase::RearrangeItemBounds() - { - vint newStartIndex = startIndex; - BeginPlaceItem(false, viewBounds, newStartIndex); - for (vint i = 0; i < visibleStyles.Count(); i++) - { - auto style = visibleStyles[i]; - Rect bounds; - Margin alignmentToParent(-1, -1, -1, -1); - PlaceItem(false, startIndex + i, style, viewBounds, bounds, alignmentToParent); - - bounds.x1 -= viewBounds.x1; - bounds.x2 -= viewBounds.x1; - bounds.y1 -= viewBounds.y1; - bounds.y2 -= viewBounds.y1; - - callback->SetStyleAlignmentToParent(GetStyleBounds(style), alignmentToParent); - callback->SetStyleBounds(GetStyleBounds(style), bounds); - } - EndPlaceItem(false, viewBounds, startIndex); - } - - RangedItemArrangerBase::RangedItemArrangerBase() - { - } - - RangedItemArrangerBase::~RangedItemArrangerBase() - { - } - - void RangedItemArrangerBase::OnAttached(GuiListControl::IItemProvider* provider) - { - itemProvider = provider; - if (provider) - { - OnItemModified(0, 0, provider->Count()); - } - } - - void RangedItemArrangerBase::OnItemModified(vint start, vint count, vint newCount) - { - if (callback && !itemProvider->IsEditing()) - { - suppressOnViewChanged = true; - { - vint visibleCount = visibleStyles.Count(); - vint itemCount = itemProvider->Count(); - SortedList reusedStyles; - for (vint i = 0; i < visibleCount; i++) - { - vint index = startIndex + i; - if (index >= itemCount) - { - break; - } - - vint oldIndex = -1; - if (index < start) - { - oldIndex = index; - } - else if (index >= start + newCount) - { - oldIndex = index - newCount + count; - } - - if (oldIndex != -1) - { - if (oldIndex >= startIndex && oldIndex < startIndex + visibleCount) - { - auto style = visibleStyles[oldIndex - startIndex]; - reusedStyles.Add(style); - visibleStyles.Add(style); - } - else - { - oldIndex = -1; - } - } - if (oldIndex == -1) - { - visibleStyles.Add(CreateStyle(index)); - } - } - - for (vint i = 0; i < visibleCount; i++) - { - auto style = visibleStyles[i]; - if (!reusedStyles.Contains(style)) - { - DeleteStyle(style); - } - } - - visibleStyles.RemoveRange(0, visibleCount); - for (vint i = 0; i < visibleStyles.Count(); i++) - { - visibleStyles[i].key->SetIndex(startIndex + i); - } - } - suppressOnViewChanged = false; - - callback->OnTotalSizeChanged(); - callback->SetViewLocation(viewBounds.LeftTop()); - InvalidateAdoptedSize(); - } - } - - void RangedItemArrangerBase::AttachListControl(GuiListControl* value) - { - listControl = value; - InvalidateAdoptedSize(); - } - - void RangedItemArrangerBase::DetachListControl() - { - listControl = 0; - } - - GuiListControl::IItemArrangerCallback* RangedItemArrangerBase::GetCallback() - { - return callback; - } - - void RangedItemArrangerBase::SetCallback(GuiListControl::IItemArrangerCallback* value) - { - if (callback != value) - { - ClearStyles(); - } - callback = value; - } - - Size RangedItemArrangerBase::GetTotalSize() - { - if (callback) - { - return OnCalculateTotalSize(); - } - else - { - return Size(0, 0); - } - } - - GuiListControl::ItemStyle* RangedItemArrangerBase::GetVisibleStyle(vint itemIndex) - { - if (startIndex <= itemIndex && itemIndex < startIndex + visibleStyles.Count()) - { - return visibleStyles[itemIndex - startIndex].key; - } - else - { - return 0; - } - } - - vint RangedItemArrangerBase::GetVisibleIndex(GuiListControl::ItemStyle* style) - { - for (vint i = 0; i < visibleStyles.Count(); i++) - { - if (visibleStyles[i].key == style) - { - return i + startIndex; - } - } - return -1; - } - - void RangedItemArrangerBase::OnViewChanged(Rect bounds) - { - if (!suppressOnViewChanged) - { - suppressOnViewChanged = true; - Rect oldBounds = viewBounds; - viewBounds = bounds; - if (callback) - { - OnViewChangedInternal(oldBounds, viewBounds); - RearrangeItemBounds(); - } - suppressOnViewChanged = false; - } - } - -/*********************************************************************** -FixedHeightItemArranger -***********************************************************************/ - - vint FixedHeightItemArranger::GetWidth() - { - return -1; - } - - vint FixedHeightItemArranger::GetYOffset() - { - return 0; - } - - void FixedHeightItemArranger::BeginPlaceItem(bool forMoving, Rect newBounds, vint& newStartIndex) - { - pi_width = GetWidth(); - if (forMoving) - { - pim_rowHeight = rowHeight; - newStartIndex = (newBounds.Top() - GetYOffset()) / rowHeight; - } - } - - void FixedHeightItemArranger::PlaceItem(bool forMoving, vint index, ItemStyleRecord style, Rect viewBounds, Rect& bounds, Margin& alignmentToParent) - { - vint top = GetYOffset() + index * rowHeight; - if (pi_width == -1) - { - alignmentToParent = Margin(0, -1, 0, -1); - bounds = Rect(Point(0, top), Size(0, rowHeight)); - } - else - { - alignmentToParent = Margin(-1, -1, -1, -1); - bounds = Rect(Point(0, top), Size(pi_width, rowHeight)); - } - if (forMoving) - { - vint styleHeight = callback->GetStylePreferredSize(GetStyleBounds(style)).y; - if (pim_rowHeight < styleHeight) - { - pim_rowHeight = styleHeight; - } - } - } - - bool FixedHeightItemArranger::IsItemOutOfViewBounds(vint index, ItemStyleRecord style, Rect bounds, Rect viewBounds) - { - return bounds.Top() >= viewBounds.Bottom(); - } - - bool FixedHeightItemArranger::EndPlaceItem(bool forMoving, Rect newBounds, vint newStartIndex) - { - if (forMoving) - { - if (pim_rowHeight != rowHeight) - { - vint offset = (pim_rowHeight - rowHeight) * newStartIndex; - rowHeight = pim_rowHeight; - callback->SetViewLocation(Point(0, newBounds.Top() + offset)); - return true; - } - } - return false; - } - - void FixedHeightItemArranger::InvalidateItemSizeCache() - { - rowHeight = 1; - } - - Size FixedHeightItemArranger::OnCalculateTotalSize() - { - vint width = GetWidth(); - if (width < 0) width = 0; - return Size(width, rowHeight * itemProvider->Count() + GetYOffset()); - } - - FixedHeightItemArranger::FixedHeightItemArranger() - :rowHeight(1) - { - } - - FixedHeightItemArranger::~FixedHeightItemArranger() - { - } - - vint FixedHeightItemArranger::FindItem(vint itemIndex, compositions::KeyDirection key) - { - vint count = itemProvider->Count(); - if (count == 0) return -1; - vint groupCount = viewBounds.Height() / rowHeight; - if (groupCount == 0) groupCount = 1; - switch (key) - { - case KeyDirection::Up: - itemIndex--; - break; - case KeyDirection::Down: - itemIndex++; - break; - case KeyDirection::Home: - itemIndex = 0; - break; - case KeyDirection::End: - itemIndex = count; - break; - case KeyDirection::PageUp: - itemIndex -= groupCount; - break; - case KeyDirection::PageDown: - itemIndex += groupCount; - break; - default: - return -1; - } - - if (itemIndex < 0) return 0; - else if (itemIndex >= count) return count - 1; - else return itemIndex; - } - - bool FixedHeightItemArranger::EnsureItemVisible(vint itemIndex) - { - if (callback) - { - if (itemIndex < 0 || itemIndex >= itemProvider->Count()) - { - return false; - } - while (true) - { - vint yOffset = GetYOffset(); - vint top = itemIndex*rowHeight; - vint bottom = top + rowHeight + yOffset; - - if (viewBounds.Height() < rowHeight) - { - if (viewBounds.Top() < bottom && top < viewBounds.Bottom()) - { - break; - } - } - - Point location = viewBounds.LeftTop(); - if (top < viewBounds.Top()) - { - location.y = top; - } - else if (viewBounds.Bottom() < bottom) - { - location.y = bottom - viewBounds.Height(); - } - else - { - break; - } - callback->SetViewLocation(location); - } - return true; - } - return false; - } - - Size FixedHeightItemArranger::GetAdoptedSize(Size expectedSize) - { - if (itemProvider) - { - vint yOffset = GetYOffset(); - vint y = expectedSize.y - yOffset; - vint itemCount = itemProvider->Count(); - return Size(expectedSize.x, yOffset + CalculateAdoptedSize(y, itemCount, rowHeight)); - } - return expectedSize; - } - -/*********************************************************************** -FixedSizeMultiColumnItemArranger -***********************************************************************/ - - void FixedSizeMultiColumnItemArranger::BeginPlaceItem(bool forMoving, Rect newBounds, vint& newStartIndex) - { - if (forMoving) - { - pim_itemSize = itemSize; - vint rows = newBounds.Top() / itemSize.y; - if (rows < 0) rows = 0; - vint cols = newBounds.Width() / itemSize.x; - if (cols < 1) cols = 1; - newStartIndex = rows * cols; - } - } - - void FixedSizeMultiColumnItemArranger::PlaceItem(bool forMoving, vint index, ItemStyleRecord style, Rect viewBounds, Rect& bounds, Margin& alignmentToParent) - { - vint rowItems = viewBounds.Width() / itemSize.x; - if (rowItems < 1) rowItems = 1; - - vint row = index / rowItems; - vint col = index % rowItems; - bounds = Rect(Point(col * itemSize.x, row * itemSize.y), itemSize); - if (forMoving) - { - Size styleSize = callback->GetStylePreferredSize(GetStyleBounds(style)); - if (pim_itemSize.x < styleSize.x) pim_itemSize.x = styleSize.x; - if (pim_itemSize.y < styleSize.y) pim_itemSize.y = styleSize.y; - } - } - - bool FixedSizeMultiColumnItemArranger::IsItemOutOfViewBounds(vint index, ItemStyleRecord style, Rect bounds, Rect viewBounds) - { - return bounds.Top() >= viewBounds.Bottom(); - } - - bool FixedSizeMultiColumnItemArranger::EndPlaceItem(bool forMoving, Rect newBounds, vint newStartIndex) - { - if (forMoving) - { - if (pim_itemSize != itemSize) - { - itemSize = pim_itemSize; - return true; - } - } - return false; - } - - void FixedSizeMultiColumnItemArranger::CalculateRange(Size itemSize, Rect bounds, vint count, vint& start, vint& end) - { - vint startRow = bounds.Top() / itemSize.y; - if (startRow < 0) startRow = 0; - vint endRow = (bounds.Bottom() - 1) / itemSize.y; - vint cols = bounds.Width() / itemSize.x; - if (cols < 1) cols = 1; - - start = startRow*cols; - end = (endRow + 1)*cols - 1; - if (end >= count) end = count - 1; - } - - void FixedSizeMultiColumnItemArranger::InvalidateItemSizeCache() - { - itemSize = Size(1, 1); - } - - Size FixedSizeMultiColumnItemArranger::OnCalculateTotalSize() - { - vint rowItems = viewBounds.Width() / itemSize.x; - if (rowItems < 1) rowItems = 1; - vint rows = itemProvider->Count() / rowItems; - if (itemProvider->Count() % rowItems) rows++; - - return Size(itemSize.x * rowItems, itemSize.y*rows); - } - - FixedSizeMultiColumnItemArranger::FixedSizeMultiColumnItemArranger() - :itemSize(1, 1) - { - } - - FixedSizeMultiColumnItemArranger::~FixedSizeMultiColumnItemArranger() - { - } - - vint FixedSizeMultiColumnItemArranger::FindItem(vint itemIndex, compositions::KeyDirection key) - { - vint count = itemProvider->Count(); - vint columnCount = viewBounds.Width() / itemSize.x; - if (columnCount == 0) columnCount = 1; - vint rowCount = viewBounds.Height() / itemSize.y; - if (rowCount == 0) rowCount = 1; - - switch (key) - { - case KeyDirection::Up: - itemIndex -= columnCount; - break; - case KeyDirection::Down: - itemIndex += columnCount; - break; - case KeyDirection::Left: - itemIndex--; - break; - case KeyDirection::Right: - itemIndex++; - break; - case KeyDirection::Home: - itemIndex = 0; - break; - case KeyDirection::End: - itemIndex = count; - break; - case KeyDirection::PageUp: - itemIndex -= columnCount*rowCount; - break; - case KeyDirection::PageDown: - itemIndex += columnCount*rowCount; - break; - case KeyDirection::PageLeft: - itemIndex -= itemIndex%columnCount; - break; - case KeyDirection::PageRight: - itemIndex += columnCount - itemIndex%columnCount - 1; - break; - default: - return -1; - } - - if (itemIndex < 0) return 0; - else if (itemIndex >= count) return count - 1; - else return itemIndex; - } - - bool FixedSizeMultiColumnItemArranger::EnsureItemVisible(vint itemIndex) - { - if (callback) - { - if (itemIndex < 0 || itemIndex >= itemProvider->Count()) - { - return false; - } - while (true) - { - vint rowHeight = itemSize.y; - vint columnCount = viewBounds.Width() / itemSize.x; - if (columnCount == 0) columnCount = 1; - vint rowIndex = itemIndex / columnCount; - - vint top = rowIndex*rowHeight; - vint bottom = top + rowHeight; - - if (viewBounds.Height() < rowHeight) - { - if (viewBounds.Top() < bottom && top < viewBounds.Bottom()) - { - break; - } - } - - Point location = viewBounds.LeftTop(); - if (top < viewBounds.Top()) - { - location.y = top; - } - else if (viewBounds.Bottom() < bottom) - { - location.y = bottom - viewBounds.Height(); - } - else - { - break; - } - callback->SetViewLocation(location); - } - return true; - } - return false; - } - - Size FixedSizeMultiColumnItemArranger::GetAdoptedSize(Size expectedSize) - { - if (itemProvider) - { - vint count = itemProvider->Count(); - vint columnCount = viewBounds.Width() / itemSize.x; - vint rowCount = viewBounds.Height() / itemSize.y; - return Size( - CalculateAdoptedSize(expectedSize.x, columnCount, itemSize.x), - CalculateAdoptedSize(expectedSize.y, rowCount, itemSize.y) - ); - } - return expectedSize; - } - -/*********************************************************************** -FixedHeightMultiColumnItemArranger -***********************************************************************/ - - void FixedHeightMultiColumnItemArranger::BeginPlaceItem(bool forMoving, Rect newBounds, vint& newStartIndex) - { - pi_currentWidth = 0; - pi_totalWidth = 0; - if (forMoving) - { - pim_itemHeight = itemHeight; - vint rows = newBounds.Height() / itemHeight; - if (rows < 1) rows = 1; - vint columns = newBounds.Left() / newBounds.Width(); - newStartIndex = rows * columns; - } - } - - void FixedHeightMultiColumnItemArranger::PlaceItem(bool forMoving, vint index, ItemStyleRecord style, Rect viewBounds, Rect& bounds, Margin& alignmentToParent) - { - vint rows = viewBounds.Height() / itemHeight; - if (rows < 1) rows = 1; - - vint row = index % rows; - if (row == 0) - { - pi_totalWidth += pi_currentWidth; - pi_currentWidth = 0; - } - - Size styleSize = callback->GetStylePreferredSize(GetStyleBounds(style)); - if (pi_currentWidth < styleSize.x) pi_currentWidth = styleSize.x; - bounds = Rect(Point(pi_totalWidth + viewBounds.Left(), itemHeight * row), Size(0, 0)); - if (forMoving) - { - if (pim_itemHeight < styleSize.y) pim_itemHeight = styleSize.y; - } - } - - bool FixedHeightMultiColumnItemArranger::IsItemOutOfViewBounds(vint index, ItemStyleRecord style, Rect bounds, Rect viewBounds) - { - return bounds.Left() >= viewBounds.Right(); - } - - bool FixedHeightMultiColumnItemArranger::EndPlaceItem(bool forMoving, Rect newBounds, vint newStartIndex) - { - if (forMoving) - { - if (pim_itemHeight != itemHeight) - { - itemHeight = pim_itemHeight; - return true; - } - } - return false; - } - - void FixedHeightMultiColumnItemArranger::CalculateRange(vint itemHeight, Rect bounds, vint& rows, vint& startColumn) - { - rows = bounds.Height() / itemHeight; - if (rows < 1) rows = 1; - startColumn = bounds.Left() / bounds.Width(); - } - - void FixedHeightMultiColumnItemArranger::InvalidateItemSizeCache() - { - itemHeight = 1; - } - - Size FixedHeightMultiColumnItemArranger::OnCalculateTotalSize() - { - vint rows = viewBounds.Height() / itemHeight; - if (rows < 1) rows = 1; - vint columns = itemProvider->Count() / rows; - if (itemProvider->Count() % rows) columns += 1; - return Size(viewBounds.Width() * columns, 0); - } - - FixedHeightMultiColumnItemArranger::FixedHeightMultiColumnItemArranger() - :itemHeight(1) - { - } - - FixedHeightMultiColumnItemArranger::~FixedHeightMultiColumnItemArranger() - { - } - - vint FixedHeightMultiColumnItemArranger::FindItem(vint itemIndex, compositions::KeyDirection key) - { - vint count = itemProvider->Count(); - vint groupCount = viewBounds.Height() / itemHeight; - if (groupCount == 0) groupCount = 1; - switch (key) - { - case KeyDirection::Up: - itemIndex--; - break; - case KeyDirection::Down: - itemIndex++; - break; - case KeyDirection::Left: - itemIndex -= groupCount; - break; - case KeyDirection::Right: - itemIndex += groupCount; - break; - case KeyDirection::Home: - itemIndex = 0; - break; - case KeyDirection::End: - itemIndex = count; - break; - case KeyDirection::PageUp: - itemIndex -= itemIndex%groupCount; - break; - case KeyDirection::PageDown: - itemIndex += groupCount - itemIndex%groupCount - 1; - break; - default: - return -1; - } - - if (itemIndex < 0) return 0; - else if (itemIndex >= count) return count - 1; - else return itemIndex; - } - - bool FixedHeightMultiColumnItemArranger::EnsureItemVisible(vint itemIndex) - { - if (callback) - { - if (itemIndex < 0 || itemIndex >= itemProvider->Count()) - { - return false; - } - while (true) - { - vint rowCount = viewBounds.Height() / itemHeight; - if (rowCount == 0) rowCount = 1; - vint columnIndex = itemIndex / rowCount; - vint minIndex = startIndex; - vint maxIndex = startIndex + visibleStyles.Count() - 1; - - Point location = viewBounds.LeftTop(); - if (minIndex <= itemIndex && itemIndex <= maxIndex) - { - Rect bounds = callback->GetStyleBounds(GetStyleBounds(visibleStyles[itemIndex - startIndex])); - if (0 < bounds.Bottom() && bounds.Top() < viewBounds.Width() && bounds.Width() > viewBounds.Width()) - { - break; - } - else if (bounds.Left() < 0) - { - location.x -= viewBounds.Width(); - } - else if (bounds.Right() > viewBounds.Width()) - { - location.x += viewBounds.Width(); - } - else - { - break; - } - } - else if (columnIndex < minIndex / rowCount) - { - location.x -= viewBounds.Width(); - } - else if (columnIndex >= maxIndex / rowCount) - { - location.x += viewBounds.Width(); - } - else - { - break; - } - callback->SetViewLocation(location); - } - return true; - } - return false; - } - - Size FixedHeightMultiColumnItemArranger::GetAdoptedSize(Size expectedSize) - { - if (itemProvider) - { - vint count = itemProvider->Count(); - return Size(expectedSize.x, CalculateAdoptedSize(expectedSize.y, count, itemHeight)); - } - return expectedSize; - } - } - } - } -} - /*********************************************************************** .\CONTROLS\LISTCONTROLPACKAGE\GUILISTVIEWCONTROLS.CPP ***********************************************************************/ @@ -21034,7 +20954,7 @@ GuiListView } /*********************************************************************** -.\CONTROLS\LISTCONTROLPACKAGE\GUITEXTLISTCONTROLS.CPP +.\CONTROLS\LISTCONTROLPACKAGE\GUILISTVIEWITEMTEMPLATES.CPP ***********************************************************************/ namespace vl @@ -21043,392 +20963,710 @@ namespace vl { namespace controls { - using namespace collections; using namespace elements; using namespace compositions; + using namespace collections; using namespace reflection::description; namespace list { - const wchar_t* const ITextItemView::Identifier = L"vl::presentation::controls::list::ITextItemView"; /*********************************************************************** -DefaultTextListItemTemplate +DefaultListViewItemTemplate ***********************************************************************/ - TemplateProperty DefaultTextListItemTemplate::CreateBulletStyle() + DefaultListViewItemTemplate::DefaultListViewItemTemplate() { - return {}; + SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); } - void DefaultTextListItemTemplate::OnInitialize() + DefaultListViewItemTemplate::~DefaultListViewItemTemplate() { - templates::GuiTextListItemTemplate::OnInitialize(); - SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + } - textElement = GuiSolidLabelElement::Create(); - textElement->SetAlignments(Alignment::Left, Alignment::Center); +/*********************************************************************** +BigIconListViewItemTemplate +***********************************************************************/ - GuiBoundsComposition* textComposition = new GuiBoundsComposition; - textComposition->SetOwnedElement(textElement); - textComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElement); - - if (auto bulletStyleController = CreateBulletStyle()) + void BigIconListViewItemTemplate::OnInitialize() + { + DefaultListViewItemTemplate::OnInitialize(); { - bulletButton = new GuiSelectableButton(theme::ThemeName::Unknown); - bulletButton->SetControlTemplate(bulletStyleController); - bulletButton->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); - bulletButton->SelectedChanged.AttachMethod(this, &DefaultTextListItemTemplate::OnBulletSelectedChanged); - - GuiTableComposition* table = new GuiTableComposition; + auto table = new GuiTableComposition; AddChild(table); + table->SetRowsAndColumns(2, 3); + table->SetRowOption(0, GuiCellOption::MinSizeOption()); + table->SetRowOption(1, GuiCellOption::MinSizeOption()); + table->SetColumnOption(0, GuiCellOption::PercentageOption(0.5)); + table->SetColumnOption(1, GuiCellOption::MinSizeOption()); + table->SetColumnOption(2, GuiCellOption::PercentageOption(0.5)); table->SetAlignmentToParent(Margin(0, 0, 0, 0)); - table->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - table->SetRowsAndColumns(1, 2); - table->SetRowOption(0, GuiCellOption::PercentageOption(1.0)); - table->SetColumnOption(0, GuiCellOption::MinSizeOption()); - table->SetColumnOption(1, GuiCellOption::PercentageOption(1.0)); + table->SetCellPadding(5); { - GuiCellComposition* cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(0, 0, 1, 1); - cell->AddChild(bulletButton->GetBoundsComposition()); - } - { - GuiCellComposition* cell = new GuiCellComposition; + auto cell = new GuiCellComposition; table->AddChild(cell); cell->SetSite(0, 1, 1, 1); - cell->AddChild(textComposition); - textComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + cell->SetPreferredMinSize(Size(32, 32)); + + image = GuiImageFrameElement::Create(); + image->SetStretch(true); + cell->SetOwnedElement(image); + } + { + auto cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetMinSizeLimitation(GuiGraphicsComposition::NoLimit); + cell->SetSite(1, 0, 1, 3); + cell->SetPreferredMinSize(Size(64, 40)); + + text = GuiSolidLabelElement::Create(); + text->SetAlignments(Alignment::Center, Alignment::Top); + text->SetWrapLine(true); + text->SetEllipse(true); + cell->SetOwnedElement(text); } } - else + + if (auto listView = dynamic_cast(listControl)) { - AddChild(textComposition); - textComposition->SetAlignmentToParent(Margin(5, 0, 0, 0)); + auto itemIndex = GetIndex(); + if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) + { + auto imageData = view->GetLargeImage(itemIndex); + if (imageData) + { + image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); + } + else + { + image->SetImage(nullptr); + } + text->SetText(view->GetText(itemIndex)); + text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); + } } - FontChanged.AttachMethod(this, &DefaultTextListItemTemplate::OnFontChanged); - TextChanged.AttachMethod(this, &DefaultTextListItemTemplate::OnTextChanged); - TextColorChanged.AttachMethod(this, &DefaultTextListItemTemplate::OnTextColorChanged); - CheckedChanged.AttachMethod(this, &DefaultTextListItemTemplate::OnCheckedChanged); + FontChanged.AttachMethod(this, &BigIconListViewItemTemplate::OnFontChanged); FontChanged.Execute(compositions::GuiEventArgs(this)); - TextChanged.Execute(compositions::GuiEventArgs(this)); - TextColorChanged.Execute(compositions::GuiEventArgs(this)); - CheckedChanged.Execute(compositions::GuiEventArgs(this)); } - void DefaultTextListItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + void BigIconListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - textElement->SetFont(GetFont()); + text->SetFont(GetFont()); } - void DefaultTextListItemTemplate::OnTextChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + BigIconListViewItemTemplate::BigIconListViewItemTemplate() { - textElement->SetText(GetText()); } - void DefaultTextListItemTemplate::OnTextColorChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + BigIconListViewItemTemplate::~BigIconListViewItemTemplate() { - textElement->SetColor(GetTextColor()); } - void DefaultTextListItemTemplate::OnCheckedChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) +/*********************************************************************** +SmallIconListViewItemTemplate +***********************************************************************/ + + void SmallIconListViewItemTemplate::OnInitialize() { - if (bulletButton) + DefaultListViewItemTemplate::OnInitialize(); { - supressEdit = true; - bulletButton->SetSelected(GetChecked()); - supressEdit = false; - } - } - - void DefaultTextListItemTemplate::OnBulletSelectedChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if (!supressEdit) - { - if (auto textItemView = dynamic_cast(listControl->GetItemProvider()->RequestView(ITextItemView::Identifier))) + auto table = new GuiTableComposition; + AddChild(table); + table->SetRowsAndColumns(3, 2); + table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); + table->SetRowOption(1, GuiCellOption::MinSizeOption()); + table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); + table->SetColumnOption(0, GuiCellOption::MinSizeOption()); + table->SetColumnOption(1, GuiCellOption::MinSizeOption()); + table->SetAlignmentToParent(Margin(0, 0, 0, 0)); + table->SetCellPadding(2); { - BeginEditListItem(); - textItemView->SetChecked(GetIndex(), bulletButton->GetSelected()); - EndEditListItem(); + GuiCellComposition* cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(1, 0, 1, 1); + cell->SetPreferredMinSize(Size(16, 16)); + + image = GuiImageFrameElement::Create(); + image->SetStretch(true); + cell->SetOwnedElement(image); + } + { + GuiCellComposition* cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(0, 1, 3, 1); + cell->SetPreferredMinSize(Size(192, 0)); + + text = GuiSolidLabelElement::Create(); + text->SetAlignments(Alignment::Left, Alignment::Center); + text->SetEllipse(true); + cell->SetOwnedElement(text); + } + } + + if (auto listView = dynamic_cast(listControl)) + { + auto itemIndex = GetIndex(); + if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) + { + auto imageData = view->GetSmallImage(itemIndex); + if (imageData) + { + image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); + } + else + { + image->SetImage(nullptr); + } + text->SetText(view->GetText(itemIndex)); + text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); + } + } + + FontChanged.AttachMethod(this, &SmallIconListViewItemTemplate::OnFontChanged); + + FontChanged.Execute(compositions::GuiEventArgs(this)); + } + + void SmallIconListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + text->SetFont(GetFont()); + } + + SmallIconListViewItemTemplate::SmallIconListViewItemTemplate() + { + } + + SmallIconListViewItemTemplate::~SmallIconListViewItemTemplate() + { + } + +/*********************************************************************** +ListListViewItemTemplate +***********************************************************************/ + + void ListListViewItemTemplate::OnInitialize() + { + DefaultListViewItemTemplate::OnInitialize(); + { + auto table = new GuiTableComposition; + AddChild(table); + table->SetRowsAndColumns(3, 2); + table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); + table->SetRowOption(1, GuiCellOption::MinSizeOption()); + table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); + table->SetColumnOption(0, GuiCellOption::MinSizeOption()); + table->SetColumnOption(1, GuiCellOption::MinSizeOption()); + table->SetAlignmentToParent(Margin(0, 0, 0, 0)); + table->SetCellPadding(2); + { + auto cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(1, 0, 1, 1); + cell->SetPreferredMinSize(Size(16, 16)); + + image = GuiImageFrameElement::Create(); + image->SetStretch(true); + cell->SetOwnedElement(image); + } + { + auto cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(0, 1, 3, 1); + cell->SetMargin(Margin(0, 0, 16, 0)); + + text = GuiSolidLabelElement::Create(); + text->SetAlignments(Alignment::Left, Alignment::Center); + cell->SetOwnedElement(text); + } + } + + if (auto listView = dynamic_cast(listControl)) + { + auto itemIndex = GetIndex(); + if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) + { + auto imageData = view->GetSmallImage(itemIndex); + if (imageData) + { + image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); + } + else + { + image->SetImage(nullptr); + } + text->SetText(view->GetText(itemIndex)); + text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); + } + } + + FontChanged.AttachMethod(this, &ListListViewItemTemplate::OnFontChanged); + + FontChanged.Execute(compositions::GuiEventArgs(this)); + } + + void ListListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + text->SetFont(GetFont()); + } + + ListListViewItemTemplate::ListListViewItemTemplate() + { + } + + ListListViewItemTemplate::~ListListViewItemTemplate() + { + } + +/*********************************************************************** +TileListViewItemTemplate +***********************************************************************/ + + elements::GuiSolidLabelElement* TileListViewItemTemplate::CreateTextElement(vint textRow) + { + auto cell = new GuiCellComposition; + textTable->AddChild(cell); + cell->SetSite(textRow + 1, 0, 1, 1); + + auto textElement = GuiSolidLabelElement::Create(); + textElement->SetAlignments(Alignment::Left, Alignment::Center); + textElement->SetEllipse(true); + cell->SetOwnedElement(textElement); + return textElement; + } + + void TileListViewItemTemplate::ResetTextTable(vint textRows) + { + textTable->SetRowsAndColumns(textRows + 2, 1); + textTable->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); + for (vint i = 0; iSetRowOption(i + 1, GuiCellOption::MinSizeOption()); + } + textTable->SetRowOption(textRows + 1, GuiCellOption::PercentageOption(0.5)); + textTable->SetColumnOption(0, GuiCellOption::PercentageOption(1.0)); + } + + void TileListViewItemTemplate::OnInitialize() + { + DefaultListViewItemTemplate::OnInitialize(); + { + auto table = new GuiTableComposition; + AddChild(table); + table->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + table->SetRowsAndColumns(3, 2); + table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); + table->SetRowOption(1, GuiCellOption::MinSizeOption()); + table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); + table->SetColumnOption(0, GuiCellOption::MinSizeOption()); + table->SetColumnOption(1, GuiCellOption::MinSizeOption()); + table->SetAlignmentToParent(Margin(0, 0, 0, 0)); + table->SetCellPadding(4); + { + auto cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(1, 0, 1, 1); + cell->SetPreferredMinSize(Size(32, 32)); + + image = GuiImageFrameElement::Create(); + image->SetStretch(true); + cell->SetOwnedElement(image); + } + { + auto cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(0, 1, 3, 1); + cell->SetPreferredMinSize(Size(224, 0)); + + textTable = new GuiTableComposition; + textTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + textTable->SetCellPadding(1); + ResetTextTable(1); + textTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); + cell->AddChild(textTable); + { + text = CreateTextElement(0); + } + } + } + + if (auto listView = dynamic_cast(listControl)) + { + auto itemIndex = GetIndex(); + if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) + { + auto imageData = view->GetLargeImage(itemIndex); + if (imageData) + { + image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); + } + else + { + image->SetImage(nullptr); + } + text->SetText(view->GetText(itemIndex)); + text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); + + vint dataColumnCount = view->GetDataColumnCount(); + ResetTextTable(dataColumnCount + 1); + dataTexts.Resize(dataColumnCount); + for (vint i = 0; i < dataColumnCount; i++) + { + dataTexts[i] = CreateTextElement(i + 1); + dataTexts[i]->SetText(view->GetSubItem(itemIndex, view->GetDataColumn(i))); + dataTexts[i]->SetColor(listView->GetControlTemplateObject()->GetSecondaryTextColor()); + } + } + } + + FontChanged.AttachMethod(this, &TileListViewItemTemplate::OnFontChanged); + + FontChanged.Execute(compositions::GuiEventArgs(this)); + } + + void TileListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + text->SetFont(GetFont()); + if (auto view = dynamic_cast(listControl->GetItemProvider()->RequestView(IListViewItemView::Identifier))) + { + vint dataColumnCount = view->GetDataColumnCount(); + for (vint i = 0; i < dataColumnCount; i++) + { + dataTexts[i]->SetFont(GetFont()); } } } - DefaultTextListItemTemplate::DefaultTextListItemTemplate() + TileListViewItemTemplate::TileListViewItemTemplate() { } - DefaultTextListItemTemplate::~DefaultTextListItemTemplate() + TileListViewItemTemplate::~TileListViewItemTemplate() { } /*********************************************************************** -DefaultCheckTextListItemTemplate +InformationListViewItemTemplate ***********************************************************************/ - TemplateProperty DefaultCheckTextListItemTemplate::CreateBulletStyle() + void InformationListViewItemTemplate::OnInitialize() { - if (auto textList = dynamic_cast(listControl)) + DefaultListViewItemTemplate::OnInitialize(); { - auto style = textList->GetControlTemplateObject()->GetCheckBulletTemplate(); - if (style) return style; - } - return theme::GetCurrentTheme()->CreateStyle(theme::ThemeName::CheckTextListItem); - } + bottomLine = GuiSolidBackgroundElement::Create(); + bottomLineComposition = new GuiBoundsComposition; + bottomLineComposition->SetOwnedElement(bottomLine); + bottomLineComposition->SetAlignmentToParent(Margin(8, -1, 8, 0)); + bottomLineComposition->SetPreferredMinSize(Size(0, 1)); + AddChild(bottomLineComposition); -/*********************************************************************** -DefaultRadioTextListItemTemplate -***********************************************************************/ - - TemplateProperty DefaultRadioTextListItemTemplate::CreateBulletStyle() - { - if (auto textList = dynamic_cast(listControl)) - { - auto style = textList->GetControlTemplateObject()->GetCheckBulletTemplate(); - if (style) return style; - } - return theme::GetCurrentTheme()->CreateStyle(theme::ThemeName::RadioTextListItem); - } - -/*********************************************************************** -TextItem -***********************************************************************/ - - TextItem::TextItem() - :owner(0) - , checked(false) - { - } - - TextItem::TextItem(const WString& _text, bool _checked) - :owner(0) - , text(_text) - , checked(_checked) - { - } - - TextItem::~TextItem() - { - } - - bool TextItem::operator==(const TextItem& value)const - { - return text==value.text; - } - - bool TextItem::operator!=(const TextItem& value)const - { - return text!=value.text; - } - - const WString& TextItem::GetText() - { - return text; - } - - void TextItem::SetText(const WString& value) - { - if (text != value) - { - text = value; - if (owner) + auto table = new GuiTableComposition; + AddChild(table); + table->SetRowsAndColumns(3, 3); + table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); + table->SetRowOption(1, GuiCellOption::MinSizeOption()); + table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); + table->SetColumnOption(0, GuiCellOption::MinSizeOption()); + table->SetColumnOption(1, GuiCellOption::PercentageOption(1.0)); + table->SetColumnOption(2, GuiCellOption::MinSizeOption()); + table->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + table->SetAlignmentToParent(Margin(0, 0, 0, 0)); + table->SetCellPadding(4); { - vint index = owner->IndexOf(this); - owner->InvokeOnItemModified(index, 1, 1); + auto cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(1, 0, 1, 1); + cell->SetPreferredMinSize(Size(32, 32)); + + image = GuiImageFrameElement::Create(); + image->SetStretch(true); + cell->SetOwnedElement(image); + } + { + auto cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(0, 1, 3, 1); + + text = GuiSolidLabelElement::Create(); + text->SetEllipse(true); + cell->SetOwnedElement(text); + } + { + auto cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(0, 2, 3, 1); + cell->SetPreferredMinSize(Size(224, 0)); + + textTable = new GuiTableComposition; + textTable->SetCellPadding(4); + textTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + textTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); + cell->AddChild(textTable); + } + } + + if (auto listView = dynamic_cast(listControl)) + { + auto itemIndex = GetIndex(); + if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) + { + auto imageData = view->GetLargeImage(itemIndex); + if (imageData) + { + image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); + } + else + { + image->SetImage(nullptr); + } + text->SetText(view->GetText(itemIndex)); + text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); + bottomLine->SetColor(listView->GetControlTemplateObject()->GetItemSeparatorColor()); + + vint dataColumnCount = view->GetDataColumnCount(); + columnTexts.Resize(dataColumnCount); + dataTexts.Resize(dataColumnCount); + + textTable->SetRowsAndColumns(dataColumnCount + 2, 1); + textTable->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); + for (vint i = 0; i < dataColumnCount; i++) + { + textTable->SetRowOption(i + 1, GuiCellOption::MinSizeOption()); + } + textTable->SetRowOption(dataColumnCount + 1, GuiCellOption::PercentageOption(0.5)); + textTable->SetColumnOption(0, GuiCellOption::PercentageOption(1.0)); + + for (vint i = 0; i < dataColumnCount; i++) + { + auto cell = new GuiCellComposition; + textTable->AddChild(cell); + cell->SetSite(i + 1, 0, 1, 1); + + auto dataTable = new GuiTableComposition; + dataTable->SetRowsAndColumns(1, 2); + dataTable->SetRowOption(0, GuiCellOption::MinSizeOption()); + dataTable->SetColumnOption(0, GuiCellOption::MinSizeOption()); + dataTable->SetColumnOption(1, GuiCellOption::PercentageOption(1.0)); + dataTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + dataTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); + cell->AddChild(dataTable); + { + auto cell = new GuiCellComposition; + dataTable->AddChild(cell); + cell->SetSite(0, 0, 1, 1); + + columnTexts[i] = GuiSolidLabelElement::Create(); + columnTexts[i]->SetText(view->GetColumnText(view->GetDataColumn(i) + 1) + L": "); + columnTexts[i]->SetColor(listView->GetControlTemplateObject()->GetSecondaryTextColor()); + cell->SetOwnedElement(columnTexts[i]); + } + { + auto cell = new GuiCellComposition; + dataTable->AddChild(cell); + cell->SetSite(0, 1, 1, 1); + + dataTexts[i]= GuiSolidLabelElement::Create(); + dataTexts[i]->SetEllipse(true); + dataTexts[i]->SetText(view->GetSubItem(itemIndex, view->GetDataColumn(i))); + dataTexts[i]->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); + cell->SetOwnedElement(dataTexts[i]); + } + } + } + } + + FontChanged.AttachMethod(this, &InformationListViewItemTemplate::OnFontChanged); + + FontChanged.Execute(compositions::GuiEventArgs(this)); + } + + void InformationListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + { + auto font = GetFont(); + font.size = (vint)(font.size * 1.2); + text->SetFont(font); + } + if (auto view = dynamic_cast(listControl->GetItemProvider()->RequestView(IListViewItemView::Identifier))) + { + vint dataColumnCount = view->GetDataColumnCount(); + for (vint i = 0; i < dataColumnCount; i++) + { + columnTexts[i]->SetFont(GetFont()); + dataTexts[i]->SetFont(GetFont()); } } } - bool TextItem::GetChecked() + InformationListViewItemTemplate::InformationListViewItemTemplate() { - return checked; } - void TextItem::SetChecked(bool value) + InformationListViewItemTemplate::~InformationListViewItemTemplate() { - if (checked != value) - { - checked = value; - if (owner) - { - vint index = owner->IndexOf(this); - owner->InvokeOnItemModified(index, 1, 1); + } - GuiItemEventArgs arguments; - arguments.itemIndex = index; - owner->listControl->ItemChecked.Execute(arguments); +/*********************************************************************** +DetailListViewItemTemplate +***********************************************************************/ + + void DetailListViewItemTemplate::OnInitialize() + { + DefaultListViewItemTemplate::OnInitialize(); + columnItemView = dynamic_cast(listControl->GetItemProvider()->RequestView(ListViewColumnItemArranger::IColumnItemView::Identifier)); + + { + textTable = new GuiTableComposition; + textTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); + textTable->SetRowsAndColumns(1, 1); + textTable->SetRowOption(0, GuiCellOption::MinSizeOption()); + textTable->SetColumnOption(0, GuiCellOption::AbsoluteOption(0)); + AddChild(textTable); + { + auto cell = new GuiCellComposition; + textTable->AddChild(cell); + cell->SetSite(0, 0, 1, 1); + + auto table = new GuiTableComposition; + cell->AddChild(table); + table->SetRowsAndColumns(3, 2); + table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); + table->SetRowOption(1, GuiCellOption::MinSizeOption()); + table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); + table->SetColumnOption(0, GuiCellOption::MinSizeOption()); + table->SetColumnOption(1, GuiCellOption::PercentageOption(1.0)); + table->SetAlignmentToParent(Margin(0, 0, 0, 0)); + table->SetCellPadding(2); + { + auto cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(1, 0, 1, 1); + cell->SetPreferredMinSize(Size(16, 16)); + + image = GuiImageFrameElement::Create(); + image->SetStretch(true); + cell->SetOwnedElement(image); + } + { + auto cell = new GuiCellComposition; + table->AddChild(cell); + cell->SetSite(0, 1, 3, 1); + cell->SetMargin(Margin(0, 0, 8, 0)); + + text = GuiSolidLabelElement::Create(); + text->SetAlignments(Alignment::Left, Alignment::Center); + text->SetEllipse(true); + cell->SetOwnedElement(text); + } + } + } + + if (auto listView = dynamic_cast(listControl)) + { + auto itemIndex = GetIndex(); + if (auto view = dynamic_cast(listView->GetItemProvider()->RequestView(IListViewItemView::Identifier))) + { + auto imageData = view->GetSmallImage(itemIndex); + if (imageData) + { + image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); + } + else + { + image->SetImage(0); + } + text->SetText(view->GetText(itemIndex)); + text->SetColor(listView->GetControlTemplateObject()->GetPrimaryTextColor()); + + vint columnCount = view->GetColumnCount() - 1; + subItems.Resize(columnCount); + textTable->SetRowsAndColumns(1, columnCount + 1); + for (vint i = 0; i < columnCount; i++) + { + auto cell = new GuiCellComposition; + textTable->AddChild(cell); + cell->SetSite(0, i + 1, 1, 1); + cell->SetMargin(Margin(8, 0, 8, 0)); + + subItems[i] = GuiSolidLabelElement::Create(); + subItems[i]->SetAlignments(Alignment::Left, Alignment::Center); + subItems[i]->SetFont(text->GetFont()); + subItems[i]->SetEllipse(true); + subItems[i]->SetText(view->GetSubItem(itemIndex, i)); + subItems[i]->SetColor(listView->GetControlTemplateObject()->GetSecondaryTextColor()); + cell->SetOwnedElement(subItems[i]); + } + OnColumnChanged(); + } + } + + FontChanged.AttachMethod(this, &DetailListViewItemTemplate::OnFontChanged); + + FontChanged.Execute(compositions::GuiEventArgs(this)); + } + + void DetailListViewItemTemplate::OnColumnChanged() + { + if (auto view = dynamic_cast(listControl->GetItemProvider()->RequestView(IListViewItemView::Identifier))) + { + if (columnItemView) + { + vint columnCount = view->GetColumnCount(); + if (columnCount>textTable->GetColumns()) + { + columnCount = textTable->GetColumns(); + } + for (vint i = 0; iSetColumnOption(i, GuiCellOption::AbsoluteOption(columnItemView->GetColumnSize(i))); + } + textTable->UpdateCellBounds(); } } } -/*********************************************************************** -TextItemProvider -***********************************************************************/ - - void TextItemProvider::AfterInsert(vint item, const Ptr& value) + void DetailListViewItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - ListProvider>::AfterInsert(item, value); - value->owner = this; - } - - void TextItemProvider::BeforeRemove(vint item, const Ptr& value) - { - value->owner = 0; - ListProvider>::BeforeRemove(item, value); - } - - WString TextItemProvider::GetTextValue(vint itemIndex) - { - return Get(itemIndex)->GetText(); - } - - description::Value TextItemProvider::GetBindingValue(vint itemIndex) - { - return Value::From(Get(itemIndex)); - } - - bool TextItemProvider::GetChecked(vint itemIndex) - { - return Get(itemIndex)->GetChecked(); - } - - void TextItemProvider::SetChecked(vint itemIndex, bool value) - { - return Get(itemIndex)->SetChecked(value); - } - - TextItemProvider::TextItemProvider() - :listControl(0) - { - } - - TextItemProvider::~TextItemProvider() - { - } - - IDescriptable* TextItemProvider::RequestView(const WString& identifier) - { - if (identifier == ITextItemView::Identifier) + text->SetFont(GetFont()); + if (auto view = dynamic_cast(listControl->GetItemProvider()->RequestView(IListViewItemView::Identifier))) { - return (ITextItemView*)this; - } - else - { - return nullptr; + vint columnCount = view->GetColumnCount() - 1; + for (vint i = 0; i < columnCount; i++) + { + subItems[i]->SetFont(GetFont()); + } } } - } -/*********************************************************************** -GuiTextList -***********************************************************************/ - - void GuiVirtualTextList::BeforeControlTemplateUninstalled_() - { - } - - void GuiVirtualTextList::AfterControlTemplateInstalled_(bool initialize) - { - } - - void GuiVirtualTextList::OnStyleInstalled(vint itemIndex, ItemStyle* style) - { - GuiSelectableListControl::OnStyleInstalled(itemIndex, style); - if (auto textItemStyle = dynamic_cast(style)) + DetailListViewItemTemplate::DetailListViewItemTemplate() { - textItemStyle->SetTextColor(GetControlTemplateObject()->GetTextColor()); - if (auto textItemView = dynamic_cast(itemProvider->RequestView(list::ITextItemView::Identifier))) - { - textItemStyle->SetChecked(textItemView->GetChecked(itemIndex)); - } } - } - void GuiVirtualTextList::OnItemTemplateChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - view = TextListView::Unknown; - } - - GuiVirtualTextList::GuiVirtualTextList(theme::ThemeName themeName, GuiListControl::IItemProvider* _itemProvider) - :GuiSelectableListControl(themeName, _itemProvider) - { - ItemTemplateChanged.AttachMethod(this, &GuiVirtualTextList::OnItemTemplateChanged); - ItemChecked.SetAssociatedComposition(boundsComposition); - - SetView(TextListView::Text); - } - - GuiVirtualTextList::~GuiVirtualTextList() - { - } - - TextListView GuiVirtualTextList::GetView() - { - return view; - } - - void GuiVirtualTextList::SetView(TextListView _view) - { - switch (_view) + DetailListViewItemTemplate::~DetailListViewItemTemplate() { - case TextListView::Text: - SetStyleAndArranger( - [](const Value&) { return new list::DefaultTextListItemTemplate; }, - new list::FixedHeightItemArranger - ); - break; - case TextListView::Check: - SetStyleAndArranger( - [](const Value&) { return new list::DefaultCheckTextListItemTemplate; }, - new list::FixedHeightItemArranger - ); - break; - case TextListView::Radio: - SetStyleAndArranger( - [](const Value&) { return new list::DefaultRadioTextListItemTemplate; }, - new list::FixedHeightItemArranger - ); - break; - default:; } - view = _view; - } - -/*********************************************************************** -GuiTextList -***********************************************************************/ - - GuiTextList::GuiTextList(theme::ThemeName themeName) - :GuiVirtualTextList(themeName, new list::TextItemProvider) - { - items=dynamic_cast(itemProvider.Obj()); - items->listControl=this; - } - - GuiTextList::~GuiTextList() - { - } - - list::TextItemProvider& GuiTextList::GetItems() - { - return *items; - } - - Ptr GuiTextList::GetSelectedItem() - { - vint index = GetSelectedItemIndex(); - if (index == -1) return 0; - return items->Get(index); } } } } /*********************************************************************** -.\CONTROLS\LISTCONTROLPACKAGE\GUITREEVIEWCONTROLS.CPP +.\CONTROLS\TEXTEDITORPACKAGE\EDITORCALLBACK\GUITEXTGENERALOPERATIONS.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace controls + { + } + } +} + +/*********************************************************************** +.\CONTROLS\TEXTEDITORPACKAGE\EDITORCALLBACK\GUITEXTCOLORIZER.CPP ***********************************************************************/ namespace vl @@ -21438,1136 +21676,932 @@ namespace vl namespace controls { using namespace elements; - using namespace compositions; - using namespace reflection::description; - - namespace tree - { - const wchar_t* const INodeItemView::Identifier = L"vl::presentation::controls::tree::INodeItemView"; + using namespace elements::text; /*********************************************************************** -NodeItemProvider +GuiTextBoxColorizerBase ***********************************************************************/ - INodeProvider* NodeItemProvider::GetNodeByOffset(INodeProvider* provider, vint offset) + void GuiTextBoxColorizerBase::ColorizerThreadProc(void* argument) + { + GuiTextBoxColorizerBase* colorizer=(GuiTextBoxColorizerBase*)argument; + while(!colorizer->isFinalizing) { - if(offset==0) return provider; - INodeProvider* result=0; - if(provider->GetExpanding() && offset>0) - { - offset-=1; - vint count=provider->GetChildCount(); - for(vint i=0;(!result && iGetChild(i); - vint visibleCount=child->CalculateTotalVisibleNodes(); - if(offsetGetExpanding()) + SPIN_LOCK(*colorizer->elementModifyLock) { - for(vint i=0;icolorizedLineCount>=colorizer->element->GetLines().GetCount()) { - INodeProvider* child=parentNode->GetChild(start+i); - offset+=child->CalculateTotalVisibleNodes(); - child->Release(); - } - } - offsetBeforeChildModifieds.Set(parentNode, offset); - } - - void NodeItemProvider::OnAfterItemModified(INodeProvider* parentNode, vint start, vint count, vint newCount) - { - vint offsetBeforeChildModified = 0; - { - vint index = offsetBeforeChildModifieds.Keys().IndexOf(parentNode); - if (index != -1) - { - offsetBeforeChildModified = offsetBeforeChildModifieds.Values().Get(index); - offsetBeforeChildModifieds.Remove(parentNode); - } - } - - vint base=CalculateNodeVisibilityIndexInternal(parentNode); - if(base!=-2 && parentNode->GetExpanding()) - { - vint offset=0; - vint firstChildStart=-1; - for(vint i=0;iGetChild(start+i); - if(i==0) - { - firstChildStart=CalculateNodeVisibilityIndexInternal(child); - } - offset+=child->CalculateTotalVisibleNodes(); - child->Release(); + colorizer->isColorizerRunning=false; + goto CANCEL_COLORIZING; } - if(firstChildStart==-1) + lineIndex=colorizer->colorizedLineCount++; + TextLine& line=colorizer->element->GetLines().GetLine(lineIndex); + length=line.dataLength; + text=new wchar_t[length+2]; + colors=new vuint32_t[length+2]; + memcpy(text, line.text, sizeof(wchar_t)*length); + text[length]=L'\r'; + text[length+1]=L'\n'; + lexerState=lineIndex==0?colorizer->GetLexerStartState():colorizer->element->GetLines().GetLine(lineIndex-1).lexerFinalState; + contextState=lineIndex==0?colorizer->GetContextStartState():colorizer->element->GetLines().GetLine(lineIndex-1).contextFinalState; + } + + colorizer->ColorizeLineWithCRLF(lineIndex, text, colors, length+2, lexerState, contextState); + + SPIN_LOCK(*colorizer->elementModifyLock) + { + if(lineIndexcolorizedLineCount && lineIndexelement->GetLines().GetCount()) { - vint childCount=parentNode->GetChildCount(); - if(childCount==0) + TextLine& line=colorizer->element->GetLines().GetLine(lineIndex); + line.lexerFinalState=lexerState; + line.contextFinalState=contextState; + for(vint i=0;iGetChild(start); - firstChildStart=CalculateNodeVisibilityIndexInternal(child); - child->Release(); - } - else - { - INodeProvider* child=parentNode->GetChild(start-1); - firstChildStart=CalculateNodeVisibilityIndexInternal(child); - firstChildStart+=child->CalculateTotalVisibleNodes(); - child->Release(); + line.att[i].colorIndex=colors[i]; } } - InvokeOnItemModified(firstChildStart, offsetBeforeChildModified, offset); + delete[] text; + delete[] colors; } } + CANCEL_COLORIZING: + colorizer->colorizerRunningEvent.Leave(); + } - void NodeItemProvider::OnItemExpanded(INodeProvider* node) + void GuiTextBoxColorizerBase::StartColorizer() + { + if(!isColorizerRunning) { - vint base=CalculateNodeVisibilityIndexInternal(node); - if(base!=-2) + isColorizerRunning=true; + colorizerRunningEvent.Enter(); + ThreadPoolLite::Queue(&GuiTextBoxColorizerBase::ColorizerThreadProc, this); + } + } + + void GuiTextBoxColorizerBase::StopColorizer(bool forever) + { + isFinalizing=true; + colorizerRunningEvent.Enter(); + colorizerRunningEvent.Leave(); + colorizedLineCount=0; + if(!forever) + { + isFinalizing=false; + } + } + + void GuiTextBoxColorizerBase::StopColorizerForever() + { + StopColorizer(true); + } + + GuiTextBoxColorizerBase::GuiTextBoxColorizerBase() + :element(0) + ,elementModifyLock(0) + ,colorizedLineCount(0) + ,isColorizerRunning(false) + ,isFinalizing(false) + { + } + + GuiTextBoxColorizerBase::~GuiTextBoxColorizerBase() + { + StopColorizerForever(); + } + + void GuiTextBoxColorizerBase::Attach(elements::GuiColorizedTextElement* _element, SpinLock& _elementModifyLock, compositions::GuiGraphicsComposition* _ownerComposition, vuint editVersion) + { + if(_element) + { + SPIN_LOCK(_elementModifyLock) { - vint visibility=node->CalculateTotalVisibleNodes(); - InvokeOnItemModified(base+1, 0, visibility-1); + element=_element; + elementModifyLock=&_elementModifyLock; + StartColorizer(); } } + } - void NodeItemProvider::OnItemCollapsed(INodeProvider* node) + void GuiTextBoxColorizerBase::Detach() + { + if(element && elementModifyLock) { - vint base=CalculateNodeVisibilityIndexInternal(node); - if(base!=-2) + StopColorizer(false); + SPIN_LOCK(*elementModifyLock) { - vint visibility=0; - vint count=node->GetChildCount(); - for(vint i=0;iline) { - INodeProvider* child=node->GetChild(i); - visibility+=child->CalculateTotalVisibleNodes(); - child->Release(); + colorizedLineCount=line; } - InvokeOnItemModified(base+1, visibility, 0); + StartColorizer(); } } + } - vint NodeItemProvider::CalculateNodeVisibilityIndexInternal(INodeProvider* node) + void GuiTextBoxColorizerBase::TextCaretChanged(const TextCaretChangedStruct& arguments) + { + } + + void GuiTextBoxColorizerBase::TextEditFinished(vuint editVersion) + { + } + + void GuiTextBoxColorizerBase::RestartColorizer() + { + if(element && elementModifyLock) { - INodeProvider* parent=node->GetParent(); - if(parent==0) + SPIN_LOCK(*elementModifyLock) { - return -1; - } - if(!parent->GetExpanding()) - { - return -2; + colorizedLineCount=0; + StartColorizer(); } + } + } - vint index=CalculateNodeVisibilityIndexInternal(parent); - if(index==-2) - { - return -2; - } +/*********************************************************************** +GuiTextBoxRegexColorizer +***********************************************************************/ - vint count=parent->GetChildCount(); - for(vint i=0;iColorizeTokenContextSensitive(data.lineIndex, data.text, start, length, token, data.contextState); + for(vint i=0;i& GuiTextBoxRegexColorizer::GetTokenRegexes() + { + return tokenRegexes; + } + + collections::List& GuiTextBoxRegexColorizer::GetTokenColors() + { + return tokenColors; + } + + collections::List& GuiTextBoxRegexColorizer::GetExtraTokenColors() + { + return extraTokenColors; + } + + vint GuiTextBoxRegexColorizer::GetExtraTokenIndexStart() + { + if(lexer) + { + return tokenColors.Count(); + } + else + { + return -1; + } + } + + bool GuiTextBoxRegexColorizer::SetDefaultColor(elements::text::ColorEntry value) + { + if(lexer) + { + return false; + } + else + { + defaultColor=value; + return true; + } + } + + vint GuiTextBoxRegexColorizer::AddToken(const WString& regex, elements::text::ColorEntry color) + { + if(lexer) + { + return -1; + } + else + { + tokenRegexes.Add(regex); + tokenColors.Add(color); + return tokenColors.Count()-1; + } + } + + vint GuiTextBoxRegexColorizer::AddExtraToken(elements::text::ColorEntry color) + { + if(lexer) + { + return -1; + } + else + { + extraTokenColors.Add(color); + return extraTokenColors.Count()-1; + } + } + + void GuiTextBoxRegexColorizer::ClearTokens() + { + tokenRegexes.Clear(); + tokenColors.Clear(); + extraTokenColors.Clear(); + lexer=0; + } + + void GuiTextBoxRegexColorizer::Setup() + { + if(lexer || tokenRegexes.Count()==0) + { + colors.Resize(1); + colors[0]=defaultColor; + } + else + { + lexer=new regex::RegexLexer(tokenRegexes); + colors.Resize(1+tokenRegexes.Count()+extraTokenColors.Count()); + colors[0]=defaultColor; + for(vint i=0;iGetChild(i); - bool findResult=child==node; - if(findResult) + colors[i+1]=tokenColors[i]; + } + for(vint i=0;iColorize()); + } + } + + void GuiTextBoxRegexColorizer::ColorizeTokenContextSensitive(vint lineIndex, const wchar_t* text, vint start, vint length, vint& token, vint& contextState) + { + } + + vint GuiTextBoxRegexColorizer::GetLexerStartState() + { + return lexer?colorizer->GetStartState():-1; + } + + vint GuiTextBoxRegexColorizer::GetContextStartState() + { + return 0; + } + + void GuiTextBoxRegexColorizer::ColorizeLineWithCRLF(vint lineIndex, const wchar_t* text, vuint32_t* colors, vint length, vint& lexerState, vint& contextState) + { + memset(colors, 0, sizeof(*colors)*length); + if(lexer) + { + GuiTextBoxRegexColorizerProcData data; + data.colorizer=this; + data.lineIndex=lineIndex; + data.text=text; + data.colors=colors; + data.contextState=contextState; + + colorizer->Reset(lexerState); + colorizer->Colorize(text, length, &GuiTextBoxRegexColorizer::ColorizerProc, &data); + + lexerState=colorizer->GetCurrentState(); + contextState=data.contextState; + } + else + { + lexerState=-1; + contextState=-1; + } + } + + const GuiTextBoxRegexColorizer::ColorArray& GuiTextBoxRegexColorizer::GetColors() + { + return colors; + } + } + } +} + +/*********************************************************************** +.\CONTROLS\LISTCONTROLPACKAGE\GUIDATAGRIDCONTROLS.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace controls + { + namespace list + { + using namespace compositions; + using namespace collections; + using namespace description; + using namespace templates; + + const wchar_t* const IDataGridView::Identifier = L"vl::presentation::controls::list::IDataGridView"; + +/*********************************************************************** +DefaultDataGridItemTemplate +***********************************************************************/ + + IDataVisualizerFactory* DefaultDataGridItemTemplate::GetDataVisualizerFactory(vint row, vint column) + { + if (auto dataGrid = dynamic_cast(listControl)) + { + if (auto factory = dataGrid->dataGridView->GetCellDataVisualizerFactory(row, column)) { - index++; + return factory; + } + + if (column == 0) + { + return dataGrid->defaultMainColumnVisualizerFactory.Obj(); } else { - index+=child->CalculateTotalVisibleNodes(); + return dataGrid->defaultSubColumnVisualizerFactory.Obj(); } - child->Release(); - if(findResult) + + } + + return nullptr; + } + + IDataEditorFactory* DefaultDataGridItemTemplate::GetDataEditorFactory(vint row, vint column) + { + if (auto dataGrid = dynamic_cast(listControl)) + { + return dataGrid->dataGridView->GetCellDataEditorFactory(row, column); + } + return nullptr; + } + + vint DefaultDataGridItemTemplate::GetCellColumnIndex(compositions::GuiGraphicsComposition* composition) + { + for (vint i = 0; i < textTable->GetColumns(); i++) + { + auto cell = textTable->GetSitedCell(0, i); + if (composition == cell) { - return index; + return i; } } return -1; } - vint NodeItemProvider::CalculateNodeVisibilityIndex(INodeProvider* node) + void DefaultDataGridItemTemplate::OnCellButtonUp(compositions::GuiGraphicsComposition* sender, bool openEditor) { - vint result=CalculateNodeVisibilityIndexInternal(node); - return result<0?-1:result; - } - - INodeProvider* NodeItemProvider::RequestNode(vint index) - { - if(root->CanGetNodeByVisibleIndex()) + if (auto dataGrid = dynamic_cast(listControl)) { - return root->GetNodeByVisibleIndex(index+1); - } - else - { - return GetNodeByOffset(root->GetRootNode(), index+1); - } - } - - void NodeItemProvider::ReleaseNode(INodeProvider* node) - { - if(node) - { - node->Release(); - } - } - - NodeItemProvider::NodeItemProvider(Ptr _root) - :root(_root) - { - root->AttachCallback(this); - } - - NodeItemProvider::~NodeItemProvider() - { - root->DetachCallback(this); - } - - Ptr NodeItemProvider::GetRoot() - { - return root; - } - - vint NodeItemProvider::Count() - { - return root->GetRootNode()->CalculateTotalVisibleNodes()-1; - } - - WString NodeItemProvider::GetTextValue(vint itemIndex) - { - if (auto node = RequestNode(itemIndex)) - { - WString result = root->GetTextValue(node); - ReleaseNode(node); - return result; - } - return L""; - } - - description::Value NodeItemProvider::GetBindingValue(vint itemIndex) - { - if (auto node = RequestNode(itemIndex)) - { - Value result = root->GetBindingValue(node); - ReleaseNode(node); - return result; - } - return Value(); - } - - IDescriptable* NodeItemProvider::RequestView(const WString& identifier) - { - if(identifier==INodeItemView::Identifier) - { - return (INodeItemView*)this; - } - else - { - return root->RequestView(identifier); - } - } - -/*********************************************************************** -MemoryNodeProvider::NodeCollection -***********************************************************************/ - - void MemoryNodeProvider::NodeCollection::OnBeforeChildModified(vint start, vint count, vint newCount) - { - ownerProvider->offsetBeforeChildModified=0; - if(ownerProvider->expanding) - { - for(vint i=0;ioffsetBeforeChildModified+=items[start+i]->totalVisibleNodeCount; - } - } - INodeProviderCallback* proxy=ownerProvider->GetCallbackProxyInternal(); - if(proxy) - { - proxy->OnBeforeItemModified(ownerProvider, start, count, newCount); - } - } - - void MemoryNodeProvider::NodeCollection::OnAfterChildModified(vint start, vint count, vint newCount) - { - ownerProvider->childCount+=(newCount-count); - if(ownerProvider->expanding) - { - vint offset=0; - for(vint i=0;itotalVisibleNodeCount; - } - ownerProvider->OnChildTotalVisibleNodesChanged(offset-ownerProvider->offsetBeforeChildModified); - } - INodeProviderCallback* proxy=ownerProvider->GetCallbackProxyInternal(); - if(proxy) - { - proxy->OnAfterItemModified(ownerProvider, start, count, newCount); - } - } - - bool MemoryNodeProvider::NodeCollection::QueryInsert(vint index, Ptr const& child) - { - return child->parent == 0; - } - - bool MemoryNodeProvider::NodeCollection::QueryRemove(vint index, Ptr const& child) - { - return child->parent == ownerProvider; - } - - void MemoryNodeProvider::NodeCollection::BeforeInsert(vint index, Ptr const& child) - { - OnBeforeChildModified(index, 0, 1); - child->parent = ownerProvider; - } - - void MemoryNodeProvider::NodeCollection::BeforeRemove(vint index, Ptr const& child) - { - OnBeforeChildModified(index, 1, 0); - child->parent = 0; - } - - void MemoryNodeProvider::NodeCollection::AfterInsert(vint index, Ptr const& child) - { - OnAfterChildModified(index, 0, 1); - } - - void MemoryNodeProvider::NodeCollection::AfterRemove(vint index, vint count) - { - OnAfterChildModified(index, count, 0); - } - - MemoryNodeProvider::NodeCollection::NodeCollection() - :ownerProvider(0) - { - } - -/*********************************************************************** -MemoryNodeProvider -***********************************************************************/ - - INodeProviderCallback* MemoryNodeProvider::GetCallbackProxyInternal() - { - if(parent) - { - return parent->GetCallbackProxyInternal(); - } - else - { - return 0; - } - } - - void MemoryNodeProvider::OnChildTotalVisibleNodesChanged(vint offset) - { - totalVisibleNodeCount+=offset; - if(parent) - { - parent->OnChildTotalVisibleNodesChanged(offset); - } - } - - MemoryNodeProvider::MemoryNodeProvider(Ptr _data) - :data(_data) - { - children.ownerProvider=this; - } - - MemoryNodeProvider::~MemoryNodeProvider() - { - } - - Ptr MemoryNodeProvider::GetData() - { - return data; - } - - void MemoryNodeProvider::SetData(const Ptr& value) - { - data=value; - NotifyDataModified(); - } - - void MemoryNodeProvider::NotifyDataModified() - { - if(parent) - { - vint index=parent->children.IndexOf(this); - INodeProviderCallback* proxy=GetCallbackProxyInternal(); - if(proxy) - { - proxy->OnBeforeItemModified(parent, index, 1, 1); - proxy->OnAfterItemModified(parent, index, 1, 1); - } - } - } - - MemoryNodeProvider::NodeCollection& MemoryNodeProvider::Children() - { - return children; - } - - bool MemoryNodeProvider::GetExpanding() - { - return expanding; - } - - void MemoryNodeProvider::SetExpanding(bool value) - { - if(expanding!=value) - { - expanding=value; - vint offset=0; - for(vint i=0;itotalVisibleNodeCount; - } - - OnChildTotalVisibleNodesChanged(expanding?offset:-offset); - INodeProviderCallback* proxy=GetCallbackProxyInternal(); - if(proxy) - { - if(expanding) + if (currentEditor && dataGrid->GetSelectedCell().column == index) { - proxy->OnItemExpanded(this); + return; + } + + vint currentRow = GetIndex(); + dataGrid->StartEdit(currentRow, index); + } + } + } + + bool DefaultDataGridItemTemplate::IsInEditor(compositions::GuiMouseEventArgs& arguments) + { + if (auto dataGrid = dynamic_cast(listControl)) + { + if (!dataGrid->currentEditor) return false; + auto editorComposition = dataGrid->currentEditor->GetTemplate(); + auto currentComposition = arguments.eventSource; + + while (currentComposition) + { + if (currentComposition == editorComposition) + { + arguments.handled = true; + return true; + } + else if (currentComposition == this) + { + break; } else { - proxy->OnItemCollapsed(this); + currentComposition = currentComposition->GetParent(); } } + } - } - - vint MemoryNodeProvider::CalculateTotalVisibleNodes() - { - return totalVisibleNodeCount; - } - - vint MemoryNodeProvider::GetChildCount() - { - return childCount; - } - - INodeProvider* MemoryNodeProvider::GetParent() - { - return parent; - } - - INodeProvider* MemoryNodeProvider::GetChild(vint index) - { - if(0<=index && indexOnBeforeItemModified(parentNode, start, count, newCount); - } - } - - void NodeRootProviderBase::OnAfterItemModified(INodeProvider* parentNode, vint start, vint count, vint newCount) - { - for(vint i=0;iOnAfterItemModified(parentNode, start, count, newCount); - } - } - - void NodeRootProviderBase::OnItemExpanded(INodeProvider* node) - { - for(vint i=0;iOnItemExpanded(node); - } - } - - void NodeRootProviderBase::OnItemCollapsed(INodeProvider* node) - { - for(vint i=0;iOnItemCollapsed(node); - } - } - - NodeRootProviderBase::NodeRootProviderBase() - { - } - - NodeRootProviderBase::~NodeRootProviderBase() - { - } - - bool NodeRootProviderBase::CanGetNodeByVisibleIndex() - { return false; } - INodeProvider* NodeRootProviderBase::GetNodeByVisibleIndex(vint index) + void DefaultDataGridItemTemplate::OnCellButtonDown(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) { - return 0; + IsInEditor(arguments); } - bool NodeRootProviderBase::AttachCallback(INodeProviderCallback* value) + void DefaultDataGridItemTemplate::OnCellLeftButtonUp(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) { - if(callbacks.Contains(value)) + if (auto dataGrid = dynamic_cast(listControl)) { - return false; - } - else - { - callbacks.Add(value); - value->OnAttached(this); - return true; - } - } - - bool NodeRootProviderBase::DetachCallback(INodeProviderCallback* value) - { - vint index=callbacks.IndexOf(value); - if(index==-1) - { - return false; - } - else - { - value->OnAttached(0); - callbacks.Remove(value); - return true; - } - } - - IDescriptable* NodeRootProviderBase::RequestView(const WString& identifier) - { - return 0; - } - -/*********************************************************************** -MemoryNodeRootProvider -***********************************************************************/ - - INodeProviderCallback* MemoryNodeRootProvider::GetCallbackProxyInternal() - { - return this; - } - - MemoryNodeRootProvider::MemoryNodeRootProvider() - { - SetExpanding(true); - } - - MemoryNodeRootProvider::~MemoryNodeRootProvider() - { - } - - INodeProvider* MemoryNodeRootProvider::GetRootNode() - { - return this; - } - - MemoryNodeProvider* MemoryNodeRootProvider::GetMemoryNode(INodeProvider* node) - { - return dynamic_cast(node); - } - } - -/*********************************************************************** -GuiVirtualTreeListControl -***********************************************************************/ - - void GuiVirtualTreeListControl::BeforeControlTemplateUninstalled_() - { - } - - void GuiVirtualTreeListControl::AfterControlTemplateInstalled_(bool initialize) - { - } - - void GuiVirtualTreeListControl::OnAttached(tree::INodeRootProvider* provider) - { - } - - void GuiVirtualTreeListControl::OnBeforeItemModified(tree::INodeProvider* parentNode, vint start, vint count, vint newCount) - { - } - - void GuiVirtualTreeListControl::OnAfterItemModified(tree::INodeProvider* parentNode, vint start, vint count, vint newCount) - { - } - - void GuiVirtualTreeListControl::OnItemExpanded(tree::INodeProvider* node) - { - GuiNodeEventArgs arguments; - (GuiEventArgs&)arguments=GetNotifyEventArguments(); - arguments.node=node; - NodeExpanded.Execute(arguments); - } - - void GuiVirtualTreeListControl::OnItemCollapsed(tree::INodeProvider* node) - { - GuiNodeEventArgs arguments; - (GuiEventArgs&)arguments=GetNotifyEventArguments(); - arguments.node=node; - NodeCollapsed.Execute(arguments); - } - - void GuiVirtualTreeListControl::OnItemMouseEvent(compositions::GuiNodeMouseEvent& nodeEvent, compositions::GuiGraphicsComposition* sender, compositions::GuiItemMouseEventArgs& arguments) - { - tree::INodeProvider* node=GetNodeItemView()->RequestNode(arguments.itemIndex); - if(node) - { - GuiNodeMouseEventArgs redirectArguments; - (GuiMouseEventArgs&)redirectArguments=arguments; - redirectArguments.node=node; - nodeEvent.Execute(redirectArguments); - (GuiMouseEventArgs&)arguments=redirectArguments; - GetNodeItemView()->ReleaseNode(node); - } - } - - void GuiVirtualTreeListControl::OnItemNotifyEvent(compositions::GuiNodeNotifyEvent& nodeEvent, compositions::GuiGraphicsComposition* sender, compositions::GuiItemEventArgs& arguments) - { - if(auto node = GetNodeItemView()->RequestNode(arguments.itemIndex)) - { - GuiNodeEventArgs redirectArguments; - (GuiEventArgs&)redirectArguments=arguments; - redirectArguments.node=node; - nodeEvent.Execute(redirectArguments); - (GuiEventArgs&)arguments=redirectArguments; - GetNodeItemView()->ReleaseNode(node); - } - } - -#define ATTACH_ITEM_MOUSE_EVENT(NODEEVENTNAME, ITEMEVENTNAME)\ - {\ - Func func(this, &GuiVirtualTreeListControl::OnItemMouseEvent);\ - ITEMEVENTNAME.AttachFunction(Curry(func)(NODEEVENTNAME));\ - }\ - -#define ATTACH_ITEM_NOTIFY_EVENT(NODEEVENTNAME, ITEMEVENTNAME)\ - {\ - Func func(this, &GuiVirtualTreeListControl::OnItemNotifyEvent);\ - ITEMEVENTNAME.AttachFunction(Curry(func)(NODEEVENTNAME));\ - }\ - - void GuiVirtualTreeListControl::OnNodeLeftButtonDoubleClick(compositions::GuiGraphicsComposition* sender, compositions::GuiNodeMouseEventArgs& arguments) - { - if (arguments.node->GetChildCount() > 0) - { - arguments.node->SetExpanding(!arguments.node->GetExpanding()); - } - } - - GuiVirtualTreeListControl::GuiVirtualTreeListControl(theme::ThemeName themeName, Ptr _nodeRootProvider) - :GuiSelectableListControl(themeName, new tree::NodeItemProvider(_nodeRootProvider)) - { - nodeItemProvider = dynamic_cast(GetItemProvider()); - nodeItemView = dynamic_cast(GetItemProvider()->RequestView(tree::INodeItemView::Identifier)); - - NodeLeftButtonDown.SetAssociatedComposition(boundsComposition); - NodeLeftButtonUp.SetAssociatedComposition(boundsComposition); - NodeLeftButtonDoubleClick.SetAssociatedComposition(boundsComposition); - NodeMiddleButtonDown.SetAssociatedComposition(boundsComposition); - NodeMiddleButtonUp.SetAssociatedComposition(boundsComposition); - NodeMiddleButtonDoubleClick.SetAssociatedComposition(boundsComposition); - NodeRightButtonDown.SetAssociatedComposition(boundsComposition); - NodeRightButtonUp.SetAssociatedComposition(boundsComposition); - NodeRightButtonDoubleClick.SetAssociatedComposition(boundsComposition); - NodeMouseMove.SetAssociatedComposition(boundsComposition); - NodeMouseEnter.SetAssociatedComposition(boundsComposition); - NodeMouseLeave.SetAssociatedComposition(boundsComposition); - NodeExpanded.SetAssociatedComposition(boundsComposition); - NodeCollapsed.SetAssociatedComposition(boundsComposition); - - ATTACH_ITEM_MOUSE_EVENT(NodeLeftButtonDown, ItemLeftButtonDown); - ATTACH_ITEM_MOUSE_EVENT(NodeLeftButtonUp, ItemLeftButtonUp); - ATTACH_ITEM_MOUSE_EVENT(NodeLeftButtonDoubleClick, ItemLeftButtonDoubleClick); - ATTACH_ITEM_MOUSE_EVENT(NodeMiddleButtonDown, ItemMiddleButtonDown); - ATTACH_ITEM_MOUSE_EVENT(NodeMiddleButtonUp, ItemMiddleButtonUp); - ATTACH_ITEM_MOUSE_EVENT(NodeMiddleButtonDoubleClick, ItemMiddleButtonDoubleClick); - ATTACH_ITEM_MOUSE_EVENT(NodeRightButtonDown, ItemRightButtonDown); - ATTACH_ITEM_MOUSE_EVENT(NodeRightButtonUp, ItemRightButtonUp); - ATTACH_ITEM_MOUSE_EVENT(NodeRightButtonDoubleClick, ItemRightButtonDoubleClick); - ATTACH_ITEM_MOUSE_EVENT(NodeMouseMove, ItemMouseMove); - ATTACH_ITEM_NOTIFY_EVENT(NodeMouseEnter, ItemMouseEnter); - ATTACH_ITEM_NOTIFY_EVENT(NodeMouseLeave, ItemMouseLeave); - - nodeItemProvider->GetRoot()->AttachCallback(this); - NodeLeftButtonDoubleClick.AttachMethod(this, &GuiVirtualTreeListControl::OnNodeLeftButtonDoubleClick); - } - -#undef ATTACH_ITEM_MOUSE_EVENT -#undef ATTACH_ITEM_NOTIFY_EVENT - - GuiVirtualTreeListControl::~GuiVirtualTreeListControl() - { - } - - tree::INodeItemView* GuiVirtualTreeListControl::GetNodeItemView() - { - return nodeItemView; - } - - tree::INodeRootProvider* GuiVirtualTreeListControl::GetNodeRootProvider() - { - return nodeItemProvider->GetRoot().Obj(); - } - - namespace tree - { - -/*********************************************************************** -TreeViewItem -***********************************************************************/ - - const wchar_t* const ITreeViewItemView::Identifier = L"vl::presentation::controls::tree::ITreeViewItemView"; - - TreeViewItem::TreeViewItem() - { - } - - TreeViewItem::TreeViewItem(const Ptr& _image, const WString& _text) - :image(_image) - ,text(_text) - { - } - -/*********************************************************************** -TreeViewItemRootProvider -***********************************************************************/ - - Ptr TreeViewItemRootProvider::GetNodeImage(INodeProvider* node) - { - MemoryNodeProvider* memoryNode=dynamic_cast(node); - if(memoryNode) - { - Ptr data=memoryNode->GetData().Cast(); - if(data) + if (!IsInEditor(arguments)) { - return data->image; - } - } - return 0; - } - - WString TreeViewItemRootProvider::GetTextValue(INodeProvider* node) - { - MemoryNodeProvider* memoryNode = dynamic_cast(node); - if (memoryNode) - { - Ptr data = memoryNode->GetData().Cast(); - if (data) - { - return data->text; - } - } - return L""; - } - - description::Value TreeViewItemRootProvider::GetBindingValue(INodeProvider* node) - { - return Value::From(GetTreeViewData(node)); - } - - TreeViewItemRootProvider::TreeViewItemRootProvider() - { - } - - TreeViewItemRootProvider::~TreeViewItemRootProvider() - { - } - - IDescriptable* TreeViewItemRootProvider::RequestView(const WString& identifier) - { - if(identifier==ITreeViewItemView::Identifier) - { - return (ITreeViewItemView*)this; - } - else - { - return MemoryNodeRootProvider::RequestView(identifier); - } - } - - Ptr TreeViewItemRootProvider::GetTreeViewData(INodeProvider* node) - { - MemoryNodeProvider* memoryNode=GetMemoryNode(node); - if(memoryNode) - { - return memoryNode->GetData().Cast(); - } - else - { - return 0; - } - } - - void TreeViewItemRootProvider::SetTreeViewData(INodeProvider* node, Ptr value) - { - MemoryNodeProvider* memoryNode=GetMemoryNode(node); - if(memoryNode) - { - memoryNode->SetData(value); - } - } - - void TreeViewItemRootProvider::UpdateTreeViewData(INodeProvider* node) - { - MemoryNodeProvider* memoryNode=GetMemoryNode(node); - if(memoryNode) - { - memoryNode->NotifyDataModified(); - } - } - } - -/*********************************************************************** -GuiVirtualTreeView -***********************************************************************/ - - templates::GuiTreeItemTemplate* GuiVirtualTreeView::GetStyleFromNode(tree::INodeProvider* node) - { - if (itemArranger) - { - vint index = nodeItemView->CalculateNodeVisibilityIndex(node); - if (index != -1) - { - auto style = itemArranger->GetVisibleStyle(index); - return dynamic_cast(style); - } - } - return nullptr; - } - - void GuiVirtualTreeView::SetStyleExpanding(tree::INodeProvider* node, bool expanding) - { - if (auto treeItemStyle = GetStyleFromNode(node)) - { - treeItemStyle->SetExpanding(expanding); - } - } - - void GuiVirtualTreeView::SetStyleExpandable(tree::INodeProvider* node, bool expandable) - { - if (auto treeItemStyle = GetStyleFromNode(node)) - { - treeItemStyle->SetExpandable(expandable); - } - } - - void GuiVirtualTreeView::OnAfterItemModified(tree::INodeProvider* parentNode, vint start, vint count, vint newCount) - { - GuiVirtualTreeListControl::OnAfterItemModified(parentNode, start, count, newCount); - SetStyleExpandable(parentNode, parentNode->GetChildCount() > 0); - } - - void GuiVirtualTreeView::OnItemExpanded(tree::INodeProvider* node) - { - GuiVirtualTreeListControl::OnItemExpanded(node); - SetStyleExpanding(node, true); - } - - void GuiVirtualTreeView::OnItemCollapsed(tree::INodeProvider* node) - { - GuiVirtualTreeListControl::OnItemCollapsed(node); - SetStyleExpanding(node, false); - } - - void GuiVirtualTreeView::OnStyleInstalled(vint itemIndex, ItemStyle* style) - { - GuiVirtualTreeListControl::OnStyleInstalled(itemIndex, style); - if (auto treeItemStyle = dynamic_cast(style)) - { - treeItemStyle->SetTextColor(GetControlTemplateObject()->GetTextColor()); - - if (treeViewItemView) - { - if (auto node = nodeItemView->RequestNode(itemIndex)) - { - treeItemStyle->SetImage(treeViewItemView->GetNodeImage(node)); - treeItemStyle->SetExpanding(node->GetExpanding()); - treeItemStyle->SetExpandable(node->GetChildCount() > 0); + if (dataGrid->GetVisuallyEnabled()) { - vint level = -1; - auto current = node; - while (current->GetParent()) - { - level++; - current = current->GetParent(); - } - treeItemStyle->SetLevel(level); + OnCellButtonUp(sender, true); } - nodeItemView->ReleaseNode(node); } } } + + void DefaultDataGridItemTemplate::OnCellRightButtonUp(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) + { + if (auto dataGrid = dynamic_cast(listControl)) + { + if (!IsInEditor(arguments)) + { + if (dataGrid->GetVisuallyEnabled()) + { + OnCellButtonUp(sender, false); + } + } + } + } + + void DefaultDataGridItemTemplate::OnColumnChanged() + { + UpdateSubItemSize(); + } + + void DefaultDataGridItemTemplate::OnInitialize() + { + DefaultListViewItemTemplate::OnInitialize(); + { + textTable = new GuiTableComposition; + textTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); + textTable->SetRowsAndColumns(1, 1); + textTable->SetRowOption(0, GuiCellOption::MinSizeOption()); + textTable->SetColumnOption(0, GuiCellOption::AbsoluteOption(0)); + AddChild(textTable); + } + + if (auto dataGrid = dynamic_cast(listControl)) + { + vint columnCount = dataGrid->listViewItemView->GetColumnCount(); + vint itemIndex = GetIndex(); + + dataVisualizers.Resize(columnCount); + for (vint i = 0; i < dataVisualizers.Count(); i++) + { + auto factory = GetDataVisualizerFactory(itemIndex, i); + dataVisualizers[i] = factory->CreateVisualizer(dataGrid); + } + + textTable->SetRowsAndColumns(1, columnCount); + for (vint i = 0; i < columnCount; i++) + { + auto cell = new GuiCellComposition; + textTable->AddChild(cell); + cell->SetSite(0, i, 1, 1); + cell->GetEventReceiver()->leftButtonDown.AttachMethod(this, &DefaultDataGridItemTemplate::OnCellButtonDown); + cell->GetEventReceiver()->rightButtonDown.AttachMethod(this, &DefaultDataGridItemTemplate::OnCellButtonDown); + cell->GetEventReceiver()->leftButtonUp.AttachMethod(this, &DefaultDataGridItemTemplate::OnCellLeftButtonUp); + cell->GetEventReceiver()->rightButtonUp.AttachMethod(this, &DefaultDataGridItemTemplate::OnCellRightButtonUp); + + auto composition = dataVisualizers[i]->GetTemplate(); + composition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + cell->AddChild(composition); + } + + for (vint i = 0; i < dataVisualizers.Count(); i++) + { + dataVisualizers[i]->BeforeVisualizeCell(dataGrid->GetItemProvider(), itemIndex, i); + } + + GridPos selectedCell = dataGrid->GetSelectedCell(); + if (selectedCell.row == itemIndex) + { + NotifySelectCell(selectedCell.column); + } + else + { + NotifySelectCell(-1); + } + UpdateSubItemSize(); + } + + SelectedChanged.AttachMethod(this, &DefaultDataGridItemTemplate::OnSelectedChanged); + FontChanged.AttachMethod(this, &DefaultDataGridItemTemplate::OnFontChanged); + + SelectedChanged.Execute(compositions::GuiEventArgs(this)); + FontChanged.Execute(compositions::GuiEventArgs(this)); + } + + void DefaultDataGridItemTemplate::OnSelectedChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if (!GetSelected()) + { + NotifySelectCell(-1); + } + } + + void DefaultDataGridItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + FOREACH(Ptr, visualizer, dataVisualizers) + { + visualizer->GetTemplate()->SetFont(GetFont()); + } + if (currentEditor) + { + currentEditor->GetTemplate()->SetFont(GetFont()); + } + } + + DefaultDataGridItemTemplate::DefaultDataGridItemTemplate() + { + } + + DefaultDataGridItemTemplate::~DefaultDataGridItemTemplate() + { + FOREACH(Ptr, visualizer, dataVisualizers) + { + visualizer->NotifyDeletedTemplate(); + } + if (currentEditor) + { + currentEditor->NotifyDeletedTemplate(); + } + } + + void DefaultDataGridItemTemplate::UpdateSubItemSize() + { + if (auto dataGrid = dynamic_cast(listControl)) + { + vint columnCount = dataGrid->listViewItemView->GetColumnCount(); + if (columnCount > textTable->GetColumns()) + { + columnCount = textTable->GetColumns(); + } + for (vint i = 0; i < columnCount; i++) + { + textTable->SetColumnOption(i, GuiCellOption::AbsoluteOption(dataGrid->columnItemView->GetColumnSize(i))); + } + textTable->UpdateCellBounds(); + } + } + + bool DefaultDataGridItemTemplate::IsEditorOpened() + { + return currentEditor != nullptr; + } + + void DefaultDataGridItemTemplate::NotifyOpenEditor(vint column, IDataEditor* editor) + { + currentEditor = editor; + if (currentEditor) + { + auto cell = textTable->GetSitedCell(0, column); + auto* editorBounds = currentEditor->GetTemplate(); + if (editorBounds->GetParent() && editorBounds->GetParent() != cell) + { + editorBounds->GetParent()->RemoveChild(editorBounds); + } + editorBounds->SetAlignmentToParent(Margin(0, 0, 0, 0)); + cell->AddChild(editorBounds); + if (auto focusControl = currentEditor->GetTemplate()->GetFocusControl()) + { + focusControl->SetFocus(); + } + } + } + + void DefaultDataGridItemTemplate::NotifyCloseEditor() + { + if (currentEditor) + { + auto composition = currentEditor->GetTemplate(); + if (composition->GetParent()) + { + composition->GetParent()->RemoveChild(composition); + } + currentEditor = nullptr; + } + } + + void DefaultDataGridItemTemplate::NotifySelectCell(vint column) + { + for (vint i = 0; i < dataVisualizers.Count(); i++) + { + dataVisualizers[i]->SetSelected(i == column); + } + } + + void DefaultDataGridItemTemplate::NotifyCellEdited() + { + for (vint i = 0; i < dataVisualizers.Count(); i++) + { + dataVisualizers[i]->BeforeVisualizeCell(listControl->GetItemProvider(), GetIndex(), i); + } + } + } + +/*********************************************************************** +GuiVirtualDataGrid (Editor) +***********************************************************************/ + + using namespace list; + + void GuiVirtualDataGrid::OnItemModified(vint start, vint count, vint newCount) + { + GuiVirtualListView::OnItemModified(start, count, newCount); + if(!GetItemProvider()->IsEditing()) + { + StopEdit(false); + } + } + + void GuiVirtualDataGrid::OnStyleUninstalled(ItemStyle* style) + { + GuiVirtualListView::OnStyleUninstalled(style); + if (auto itemStyle = dynamic_cast(style)) + { + if (itemStyle->IsEditorOpened()) + { + itemStyle->NotifyCloseEditor(); + currentEditor = nullptr; + currentEditorPos = { -1,-1 }; + } + } } - GuiVirtualTreeView::GuiVirtualTreeView(theme::ThemeName themeName, Ptr _nodeRootProvider) - :GuiVirtualTreeListControl(themeName, _nodeRootProvider) + void GuiVirtualDataGrid::NotifyCloseEditor() + { + if (currentEditorPos.row != -1 && GetArranger()) + { + auto style = GetArranger()->GetVisibleStyle(currentEditorPos.row); + if (auto itemStyle = dynamic_cast(style)) + { + itemStyle->NotifyCloseEditor(); + } + } + } + + void GuiVirtualDataGrid::NotifySelectCell(vint row, vint column) + { + selectedCell = { row, column }; + SelectedCellChanged.Execute(GetNotifyEventArguments()); + + auto style = GetArranger()->GetVisibleStyle(row); + if (auto itemStyle = dynamic_cast(style)) + { + itemStyle->NotifySelectCell(column); + } + } + + bool GuiVirtualDataGrid::StartEdit(vint row, vint column) + { + StopEdit(true); + NotifySelectCell(row, column); + + auto style = GetArranger()->GetVisibleStyle(row); + if (auto itemStyle = dynamic_cast(style)) + { + if (auto factory = dataGridView->GetCellDataEditorFactory(row, column)) + { + currentEditorOpeningEditor = true; + currentEditorPos = { row,column }; + currentEditor = factory->CreateEditor(this); + currentEditor->BeforeEditCell(GetItemProvider(), row, column); + itemStyle->NotifyOpenEditor(column, currentEditor.Obj()); + currentEditorOpeningEditor = false; + return true; + } + } + return false; + } + + void GuiVirtualDataGrid::StopEdit(bool forOpenNewEditor) + { + if (GetItemProvider()->IsEditing()) + { + NotifyCloseEditor(); + } + else + { + if (currentEditorPos != GridPos{-1, -1}) + { + if (currentEditor) + { + NotifyCloseEditor(); + } + if (!forOpenNewEditor) + { + NotifySelectCell(-1, -1); + } + } + } + currentEditor = nullptr; + currentEditorPos = { -1,-1 }; + } + +/*********************************************************************** +GuiVirtualDataGrid (IDataGridContext) +***********************************************************************/ + + templates::GuiListViewTemplate* GuiVirtualDataGrid::GetListViewControlTemplate() + { + return GetControlTemplateObject(); + } + + description::Value GuiVirtualDataGrid::GetViewModelContext() + { + return dataGridView->GetViewModelContext(); + } + + void GuiVirtualDataGrid::RequestSaveData() + { + if (currentEditor && !currentEditorOpeningEditor) + { + GuiControl* focusedControl = nullptr; + if (auto controlHost = GetRelatedControlHost()) + { + if (auto graphicsHost = controlHost->GetGraphicsHost()) + { + if (auto focusComposition = graphicsHost->GetFocusedComposition()) + { + focusedControl = focusComposition->GetRelatedControl(); + } + } + } + + GetItemProvider()->PushEditing(); + dataGridView->SetBindingCellValue(currentEditorPos.row, currentEditorPos.column, currentEditor->GetTemplate()->GetCellValue()); + GetItemProvider()->PopEditing(); + + auto style = GetArranger()->GetVisibleStyle(currentEditorPos.row); + if (auto itemStyle = dynamic_cast(style)) + { + itemStyle->NotifyCellEdited(); + } + + if (currentEditor && focusedControl) + { + focusedControl->SetFocus(); + } + } + } + +/*********************************************************************** +GuiVirtualDataGrid +***********************************************************************/ + + void GuiVirtualDataGrid::OnColumnClicked(compositions::GuiGraphicsComposition* sender, compositions::GuiItemEventArgs& arguments) + { + if(dataGridView->IsColumnSortable(arguments.itemIndex)) + { + switch(columnItemView->GetSortingState(arguments.itemIndex)) + { + case ColumnSortingState::NotSorted: + dataGridView->SortByColumn(arguments.itemIndex, true); + break; + case ColumnSortingState::Ascending: + dataGridView->SortByColumn(arguments.itemIndex, false); + break; + case ColumnSortingState::Descending: + dataGridView->SortByColumn(-1, false); + break; + } + } + } + + GuiVirtualDataGrid::GuiVirtualDataGrid(theme::ThemeName themeName, GuiListControl::IItemProvider* _itemProvider) + :GuiVirtualListView(themeName, _itemProvider) + { + listViewItemView = dynamic_cast(_itemProvider->RequestView(IListViewItemView::Identifier)); + columnItemView = dynamic_cast(_itemProvider->RequestView(ListViewColumnItemArranger::IColumnItemView::Identifier)); + dataGridView = dynamic_cast(_itemProvider->RequestView(IDataGridView::Identifier)); + + { + auto mainProperty = [](const Value&) { return new MainColumnVisualizerTemplate; }; + auto subProperty = [](const Value&) { return new SubColumnVisualizerTemplate; }; + auto cellBorderProperty = [](const Value&) { return new CellBorderVisualizerTemplate; }; + + auto mainFactory = MakePtr(mainProperty); + auto subFactory = MakePtr(subProperty); + defaultMainColumnVisualizerFactory = MakePtr(cellBorderProperty, mainFactory); + defaultSubColumnVisualizerFactory = MakePtr(cellBorderProperty, subFactory); + } + + CHECK_ERROR(listViewItemView != nullptr, L"GuiVirtualDataGrid::GuiVirtualDataGrid(IStyleController*, GuiListControl::IItemProvider*)#Missing IListViewItemView from item provider."); + CHECK_ERROR(columnItemView != nullptr, L"GuiVirtualDataGrid::GuiVirtualDataGrid(IStyleController*, GuiListControl::IItemProvider*)#Missing ListViewColumnItemArranger::IColumnItemView from item provider."); + CHECK_ERROR(dataGridView != nullptr, L"GuiVirtualDataGrid::GuiVirtualDataGrid(IStyleController*, GuiListControl::IItemProvider*)#Missing IDataGridView from item provider."); + + SetViewToDefault(); + ColumnClicked.AttachMethod(this, &GuiVirtualDataGrid::OnColumnClicked); + SelectedCellChanged.SetAssociatedComposition(boundsComposition); + } + + GuiVirtualDataGrid::~GuiVirtualDataGrid() + { + } + + GuiListControl::IItemProvider* GuiVirtualDataGrid::GetItemProvider() + { + return GuiVirtualListView::GetItemProvider(); + } + + void GuiVirtualDataGrid::SetViewToDefault() { - treeViewItemView = dynamic_cast(GetNodeRootProvider()->RequestView(tree::ITreeViewItemView::Identifier)); SetStyleAndArranger( - [](const Value&) { return new tree::DefaultTreeItemTemplate; }, - new list::FixedHeightItemArranger + [](const Value&) { return new list::DefaultDataGridItemTemplate; }, + new list::ListViewColumnItemArranger ); } - GuiVirtualTreeView::~GuiVirtualTreeView() + GridPos GuiVirtualDataGrid::GetSelectedCell() { + return selectedCell; } -/*********************************************************************** -GuiTreeView -***********************************************************************/ - - GuiTreeView::GuiTreeView(theme::ThemeName themeName) - :GuiVirtualTreeView(themeName, new tree::TreeViewItemRootProvider) + void GuiVirtualDataGrid::SetSelectedCell(const GridPos& value) { - nodes = nodeItemProvider->GetRoot().Cast(); - } - - GuiTreeView::~GuiTreeView() - { - } - - Ptr GuiTreeView::Nodes() - { - return nodes; - } - - Ptr GuiTreeView::GetSelectedItem() - { - Ptr result; - vint index = GetSelectedItemIndex(); - if (index != -1) + if (selectedCell == value) { - if (auto node = nodeItemView->RequestNode(index)) - { - if (auto memoryNode = dynamic_cast(node)) - { - result = memoryNode->GetData().Cast(); - } - nodeItemView->ReleaseNode(node); - } - } - return result; - } - - namespace tree - { - -/*********************************************************************** -DefaultTreeItemTemplate -***********************************************************************/ - - void DefaultTreeItemTemplate::OnInitialize() - { - templates::GuiTreeItemTemplate::OnInitialize(); - SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - - table = new GuiTableComposition; - AddChild(table); - table->SetRowsAndColumns(3, 4); - table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); - table->SetRowOption(1, GuiCellOption::MinSizeOption()); - table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); - table->SetColumnOption(0, GuiCellOption::AbsoluteOption(0)); - table->SetColumnOption(1, GuiCellOption::MinSizeOption()); - table->SetColumnOption(2, GuiCellOption::MinSizeOption()); - table->SetColumnOption(3, GuiCellOption::MinSizeOption()); - table->SetAlignmentToParent(Margin(0, 0, 0, 0)); - table->SetCellPadding(2); - { - GuiCellComposition* cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(0, 1, 3, 1); - cell->SetPreferredMinSize(Size(16, 16)); - - expandingButton = new GuiSelectableButton(theme::ThemeName::TreeItemExpander); - if (auto treeView = dynamic_cast(listControl)) - { - if (auto expanderStyle = treeView->GetControlTemplateObject()->GetExpandingDecoratorTemplate()) - { - expandingButton->SetControlTemplate(expanderStyle); - } - } - expandingButton->SetAutoSelection(false); - expandingButton->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); - expandingButton->GetBoundsComposition()->GetEventReceiver()->leftButtonDoubleClick.AttachMethod(this, &DefaultTreeItemTemplate::OnExpandingButtonDoubleClick); - expandingButton->Clicked.AttachMethod(this, &DefaultTreeItemTemplate::OnExpandingButtonClicked); - cell->AddChild(expandingButton->GetBoundsComposition()); - } - { - GuiCellComposition* cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(1, 2, 1, 1); - cell->SetPreferredMinSize(Size(16, 16)); - - imageElement = GuiImageFrameElement::Create(); - imageElement->SetStretch(true); - cell->SetOwnedElement(imageElement); - } - { - GuiCellComposition* cell = new GuiCellComposition; - table->AddChild(cell); - cell->SetSite(0, 3, 3, 1); - cell->SetPreferredMinSize(Size(192, 0)); - - textElement = GuiSolidLabelElement::Create(); - textElement->SetAlignments(Alignment::Left, Alignment::Center); - textElement->SetEllipse(true); - cell->SetOwnedElement(textElement); - } - - FontChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnFontChanged); - TextChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnTextChanged); - TextColorChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnTextColorChanged); - ExpandingChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnExpandingChanged); - ExpandableChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnExpandableChanged); - LevelChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnLevelChanged); - ImageChanged.AttachMethod(this, &DefaultTreeItemTemplate::OnImageChanged); - - FontChanged.Execute(compositions::GuiEventArgs(this)); - TextChanged.Execute(compositions::GuiEventArgs(this)); - TextColorChanged.Execute(compositions::GuiEventArgs(this)); - ExpandingChanged.Execute(compositions::GuiEventArgs(this)); - ExpandableChanged.Execute(compositions::GuiEventArgs(this)); - LevelChanged.Execute(compositions::GuiEventArgs(this)); - ImageChanged.Execute(compositions::GuiEventArgs(this)); + return; } - void DefaultTreeItemTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + bool validPos = 0 <= value.row && value.row < GetItemProvider()->Count() && 0 <= value.column && value.column < listViewItemView->GetColumnCount(); + StopEdit(true); + + if (validPos) { - textElement->SetFont(GetFont()); + NotifySelectCell(value.row, value.column); + } + else + { + NotifySelectCell(-1, -1); } - void DefaultTreeItemTemplate::OnTextChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + if (validPos) { - textElement->SetText(GetText()); + EnsureItemVisible(value.row); + ClearSelection(); + SetSelected(value.row, true); + StartEdit(value.row, value.column); } - - void DefaultTreeItemTemplate::OnTextColorChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - textElement->SetColor(GetTextColor()); - } - - void DefaultTreeItemTemplate::OnExpandingChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - expandingButton->SetSelected(GetExpanding()); - } - - void DefaultTreeItemTemplate::OnExpandableChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - expandingButton->SetVisible(GetExpandable()); - } - - void DefaultTreeItemTemplate::OnLevelChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - table->SetColumnOption(0, GuiCellOption::AbsoluteOption(GetLevel() * 12)); - } - - void DefaultTreeItemTemplate::OnImageChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if (auto imageData = GetImage()) - { - imageElement->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); - } - else - { - imageElement->SetImage(nullptr); - } - } - - void DefaultTreeItemTemplate::OnExpandingButtonDoubleClick(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) - { - arguments.handled = true; - } - - void DefaultTreeItemTemplate::OnExpandingButtonClicked(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if (expandingButton->GetVisuallyEnabled()) - { - if (auto treeControl = dynamic_cast(listControl)) - { - if (auto view = treeControl->GetNodeItemView()) - { - vint index = treeControl->GetArranger()->GetVisibleIndex(this); - if (index != -1) - { - if (auto node = view->RequestNode(index)) - { - bool expanding = node->GetExpanding(); - node->SetExpanding(!expanding); - view->ReleaseNode(node); - } - } - } - } - } - } - - DefaultTreeItemTemplate::DefaultTreeItemTemplate() - { - } - - DefaultTreeItemTemplate::~DefaultTreeItemTemplate() + else { + ClearSelection(); } } } @@ -22575,149 +22609,7 @@ DefaultTreeItemTemplate } /*********************************************************************** -.\CONTROLS\STYLES\GUITHEMESTYLEFACTORY.CPP -***********************************************************************/ - -namespace vl -{ - namespace presentation - { - namespace theme - { - using namespace collections; - using namespace controls; - using namespace templates; - - class Theme : public Object, public virtual theme::ITheme - { - public: - Dictionary> templates; - ThemeTemplates* first = nullptr; - ThemeTemplates* last = nullptr; - - bool RegisterTheme(const WString& name, Ptr theme) - { - CHECK_ERROR(theme->previous == nullptr, L"vl::presentation::theme::RegisterTheme(const WString&, Ptr)#Theme object has been registered"); - CHECK_ERROR(theme->next == nullptr, L"vl::presentation::theme::RegisterTheme(const WString&, Ptr)#Theme object has been registered"); - - if (templates.Keys().Contains(name)) - { - return false; - } - templates.Add(name, theme); - - if (last) - { - last->next = theme.Obj(); - } - theme->previous = last; - last = theme.Obj(); - - return true; - } - - Ptr UnregisterTheme(const WString& name) - { - vint index = templates.Keys().IndexOf(name); - if (index == -1) - { - return nullptr; - } - - auto themeTemplates = templates.Values().Get(index); - - if (themeTemplates->previous) - { - themeTemplates->previous->next = themeTemplates->next; - } - else - { - first = themeTemplates->next; - } - - if (themeTemplates->next) - { - themeTemplates->next->previous = themeTemplates->previous; - - } - else - { - last = themeTemplates->previous; - } - - templates.Remove(name); - return themeTemplates; - } - - TemplateProperty CreateStyle(ThemeName themeName)override - { - switch (themeName) - { -#define GUI_DEFINE_ITEM_PROPERTY(TEMPLATE, CONTROL) \ - case ThemeName::CONTROL:\ - {\ - auto current = last;\ - while (current) \ - {\ - if (current->CONTROL)\ - {\ - return current->CONTROL; \ - }\ - current = current->previous;\ - }\ - throw Exception(L"Control template for \"" L ## #CONTROL L"\" is not defined.");\ - }\ - - GUI_CONTROL_TEMPLATE_TYPES(GUI_DEFINE_ITEM_PROPERTY) -#undef GUI_DEFINE_ITEM_PROPERTY - default: - CHECK_FAIL(L"vl::presentation::theme::ITheme::CreateStyle(ThemeName)#Unknown theme name."); - } - } - }; - - ThemeTemplates::~ThemeTemplates() - { - FinalizeAggregation(); - } - - Theme* currentTheme = nullptr; - - ITheme* GetCurrentTheme() - { - return currentTheme; - } - - void InitializeTheme() - { - CHECK_ERROR(currentTheme == nullptr, L"vl::presentation::theme::InitializeTheme()#Theme has already been initialized"); - currentTheme = new Theme; - } - - void FinalizeTheme() - { - CHECK_ERROR(currentTheme != nullptr, L"vl::presentation::theme::FinalizeTheme()#Theme has not been initialized"); - delete currentTheme; - currentTheme = nullptr; - } - - bool RegisterTheme(const WString& name, Ptr theme) - { - CHECK_ERROR(currentTheme != nullptr, L"vl::presentation::theme::RegisterTheme(const WString&, Ptr)#Theme has already been initialized"); - return currentTheme->RegisterTheme(name, theme); - } - - Ptr UnregisterTheme(const WString& name) - { - CHECK_ERROR(currentTheme != nullptr, L"vl::presentation::theme::UnregisterTheme(const WString&)#Theme has already been initialized"); - return currentTheme->UnregisterTheme(name); - } - } - } -} - -/*********************************************************************** -.\CONTROLS\TEMPLATES\GUICONTROLTEMPLATES.CPP +.\CONTROLS\LISTCONTROLPACKAGE\GUIDATAGRIDEXTENSIONS.CPP ***********************************************************************/ namespace vl @@ -22726,1187 +22618,431 @@ namespace vl { namespace controls { - using namespace reflection::description; - + namespace list + { + using namespace compositions; + using namespace elements; + using namespace theme; + using namespace templates; + /*********************************************************************** -GuiComponent -***********************************************************************/ - - GuiComponent::GuiComponent() - { - } - - GuiComponent::~GuiComponent() - { - } - - void GuiComponent::Attach(GuiInstanceRootObject* rootObject) - { - } - - void GuiComponent::Detach(GuiInstanceRootObject* rootObject) - { - } - -/*********************************************************************** -GuiInstanceRootObject +DataVisualizerBase ***********************************************************************/ - GuiInstanceRootObject::GuiInstanceRootObject() - { - } - - GuiInstanceRootObject::~GuiInstanceRootObject() - { - } - - void GuiInstanceRootObject::FinalizeInstance() - { - if (!finalized) + DataVisualizerBase::DataVisualizerBase() { - finalized = true; + } - FOREACH(Ptr, subscription, subscriptions) + DataVisualizerBase::~DataVisualizerBase() + { + if (visualizerTemplate) { - subscription->Close(); + SafeDeleteComposition(visualizerTemplate); } - FOREACH(GuiComponent*, component, components) + } + + IDataVisualizerFactory* DataVisualizerBase::GetFactory() + { + return factory; + } + + templates::GuiGridVisualizerTemplate* DataVisualizerBase::GetTemplate() + { + return visualizerTemplate; + } + + void DataVisualizerBase::NotifyDeletedTemplate() + { + visualizerTemplate = nullptr; + } + + void DataVisualizerBase::BeforeVisualizeCell(GuiListControl::IItemProvider* itemProvider, vint row, vint column) + { + if (auto listViewItemView = dynamic_cast(dataGridContext->GetItemProvider()->RequestView(IListViewItemView::Identifier))) { - component->Detach(this); - } + auto style = dataGridContext->GetListViewControlTemplate(); + visualizerTemplate->SetPrimaryTextColor(style->GetPrimaryTextColor()); + visualizerTemplate->SetSecondaryTextColor(style->GetSecondaryTextColor()); + visualizerTemplate->SetItemSeparatorColor(style->GetItemSeparatorColor()); - subscriptions.Clear(); - for (vint i = 0; iSetLargeImage(listViewItemView->GetLargeImage(row)); + visualizerTemplate->SetSmallImage(listViewItemView->GetSmallImage(row)); + visualizerTemplate->SetText(column == 0 ? listViewItemView->GetText(row) : listViewItemView->GetSubItem(row, column - 1)); + } + if (auto dataGridView = dynamic_cast(dataGridContext->GetItemProvider()->RequestView(IDataGridView::Identifier))) { - delete components[i]; + visualizerTemplate->SetRowValue(itemProvider->GetBindingValue(row)); + visualizerTemplate->SetCellValue(dataGridView->GetBindingCellValue(row, column)); } - components.Clear(); } - } - bool GuiInstanceRootObject::IsFinalized() - { - return finalized; - } - - void GuiInstanceRootObject::FinalizeInstanceRecursively(templates::GuiTemplate* thisObject) - { - if (!finalized) + void DataVisualizerBase::SetSelected(bool value) { - NotifyFinalizeInstance(thisObject); + if (visualizerTemplate) + { + visualizerTemplate->SetSelected(value); + } } - } - void GuiInstanceRootObject::FinalizeInstanceRecursively(GuiCustomControl* thisObject) - { - if (!finalized) - { - NotifyFinalizeInstance(thisObject); - } - } +/*********************************************************************** +DataVisualizerFactory +***********************************************************************/ - void GuiInstanceRootObject::FinalizeInstanceRecursively(GuiControlHost* thisObject) - { - if (!finalized) + DataVisualizerFactory::ItemTemplate* DataVisualizerFactory::CreateItemTemplate(controls::list::IDataGridContext* dataGridContext) { - NotifyFinalizeInstance(thisObject); - } - } + ItemTemplate* itemTemplate = templateFactory(dataGridContext->GetViewModelContext()); + CHECK_ERROR(itemTemplate, L"DataVisualizerFactory::CreateItemTemplate(IDataGridContext*)#An instance of GuiGridEditorTemplate is expected."); + if (decoratedFactory) + { + auto childTemplate = decoratedFactory->CreateItemTemplate(dataGridContext); + childTemplate->SetAlignmentToParent(Margin(0, 0, 0, 0)); + itemTemplate->GetContainerComposition()->AddChild(childTemplate); - void GuiInstanceRootObject::FinalizeGeneralInstance(GuiInstanceRootObject* thisObject) - { - } +#define FORWARD_EVENT(NAME)\ + itemTemplate->NAME##Changed.AttachLambda([=](GuiGraphicsComposition* sender, GuiEventArgs& arguments)\ + {\ + childTemplate->Set##NAME(itemTemplate->Get##NAME());\ + });\ - void GuiInstanceRootObject::SetResourceResolver(Ptr resolver) - { - resourceResolver = resolver; - } +#define FORWARD_EVENT_IMPL(CLASS, TYPE, NAME) FORWARD_EVENT(NAME) - Ptr GuiInstanceRootObject::ResolveResource(const WString& protocol, const WString& path, bool ensureExist) - { - Ptr object; - if (resourceResolver) - { - object = resourceResolver->ResolveResource(protocol, path); - } - if (ensureExist && !object) - { - throw ArgumentException(L"Resource \"" + protocol + L"://" + path + L"\" does not exist."); - } - return object; - } + GuiTemplate_PROPERTIES(FORWARD_EVENT_IMPL) + GuiControlTemplate_PROPERTIES(FORWARD_EVENT_IMPL) + GuiGridCellTemplate_PROPERTIES(FORWARD_EVENT_IMPL) + GuiGridVisualizerTemplate_PROPERTIES(FORWARD_EVENT_IMPL) - Ptr GuiInstanceRootObject::AddSubscription(Ptr subscription) - { - CHECK_ERROR(finalized == false, L"GuiInstanceRootObject::AddSubscription(Ptr)#Cannot add subscription after finalizing."); - if (subscriptions.Contains(subscription.Obj())) - { - return nullptr; +#undef FORWARD_EVENT_IMPL +#undef FORWARD_EVENT + } + return itemTemplate; } - else - { - subscriptions.Add(subscription); - subscription->Open(); - subscription->Update(); - return subscription; - } - } - void GuiInstanceRootObject::UpdateSubscriptions() - { - FOREACH(Ptr, subscription, subscriptions) + DataVisualizerFactory::DataVisualizerFactory(TemplateProperty _templateFactory, Ptr _decoratedFactory) + :templateFactory(_templateFactory) + , decoratedFactory(_decoratedFactory) { - subscription->Update(); } - } - bool GuiInstanceRootObject::AddComponent(GuiComponent* component) - { - CHECK_ERROR(finalized == false, L"GuiInstanceRootObject::AddComponent(GuiComponent*>)#Cannot add component after finalizing."); - if(components.Contains(component)) + DataVisualizerFactory::~DataVisualizerFactory() { - return false; } - else + + Ptr DataVisualizerFactory::CreateVisualizer(controls::list::IDataGridContext* dataGridContext) { - components.Add(component); - component->Attach(this); + auto dataVisualizer = MakePtr(); + dataVisualizer->factory = this; + dataVisualizer->dataGridContext = dataGridContext; + dataVisualizer->visualizerTemplate = CreateItemTemplate(dataGridContext); + + return dataVisualizer; + } + +/*********************************************************************** +DataEditorBase +***********************************************************************/ + + void DataEditorBase::OnCellValueChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + dataGridContext->RequestSaveData(); + } + + DataEditorBase::DataEditorBase() + { + } + + DataEditorBase::~DataEditorBase() + { + if (editorTemplate) + { + SafeDeleteComposition(editorTemplate); + } + } + + IDataEditorFactory* DataEditorBase::GetFactory() + { + return factory; + } + + templates::GuiGridEditorTemplate* DataEditorBase::GetTemplate() + { + return editorTemplate; + } + + void DataEditorBase::NotifyDeletedTemplate() + { + editorTemplate = nullptr; + } + + void DataEditorBase::BeforeEditCell(GuiListControl::IItemProvider* itemProvider, vint row, vint column) + { + if (auto listViewItemView = dynamic_cast(dataGridContext->GetItemProvider()->RequestView(IListViewItemView::Identifier))) + { + auto style = dataGridContext->GetListViewControlTemplate(); + editorTemplate->SetPrimaryTextColor(style->GetPrimaryTextColor()); + editorTemplate->SetSecondaryTextColor(style->GetSecondaryTextColor()); + editorTemplate->SetItemSeparatorColor(style->GetItemSeparatorColor()); + + editorTemplate->SetLargeImage(listViewItemView->GetLargeImage(row)); + editorTemplate->SetSmallImage(listViewItemView->GetSmallImage(row)); + editorTemplate->SetText(column == 0 ? listViewItemView->GetText(row) : listViewItemView->GetSubItem(row, column - 1)); + } + if (auto dataGridView = dynamic_cast(dataGridContext->GetItemProvider()->RequestView(IDataGridView::Identifier))) + { + editorTemplate->SetRowValue(itemProvider->GetBindingValue(row)); + editorTemplate->SetCellValue(dataGridView->GetBindingCellValue(row, column)); + } + editorTemplate->CellValueChanged.AttachMethod(this, &DataEditorBase::OnCellValueChanged); + } + + bool DataEditorBase::GetCellValueSaved() + { + if (editorTemplate) + { + return editorTemplate->GetCellValueSaved(); + } return true; } - } - - bool GuiInstanceRootObject::AddControlHostComponent(GuiControlHost* controlHost) - { - return AddComponent(new GuiObjectComponent(controlHost)); - } - } - namespace templates - { - using namespace collections; - using namespace controls; - using namespace compositions; - using namespace elements; /*********************************************************************** -GuiTemplate +DataEditorFactory ***********************************************************************/ - GuiTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiTemplate::GuiTemplate() - :VisuallyEnabled_(true) - { - GuiTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiTemplate::~GuiTemplate() - { - FinalizeInstanceRecursively(this); - } - -/*********************************************************************** -GuiControlTemplate -***********************************************************************/ - - GuiControlTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiControlTemplate::GuiControlTemplate() - :ContainerComposition_(this) - , FocusableComposition_(0) - { - GuiControlTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiControlTemplate::~GuiControlTemplate() - { - FinalizeAggregation(); - } - - void GuiControlTemplate::Initialize() - { - } - -/*********************************************************************** -GuiLabelTemplate -***********************************************************************/ - - GuiLabelTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiLabelTemplate::GuiLabelTemplate() - { - GuiLabelTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiLabelTemplate::~GuiLabelTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiSinglelineTextBoxTemplate -***********************************************************************/ - - GuiSinglelineTextBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiSinglelineTextBoxTemplate::GuiSinglelineTextBoxTemplate() - { - GuiSinglelineTextBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiSinglelineTextBoxTemplate::~GuiSinglelineTextBoxTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiDocumentLabelTemplate -***********************************************************************/ - - GuiDocumentLabelTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiDocumentLabelTemplate::GuiDocumentLabelTemplate() - { - GuiDocumentLabelTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiDocumentLabelTemplate::~GuiDocumentLabelTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiMenuTemplate -***********************************************************************/ - - GuiMenuTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiMenuTemplate::GuiMenuTemplate() - { - GuiMenuTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiMenuTemplate::~GuiMenuTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiWindowTemplate -***********************************************************************/ - - GuiWindowTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiWindowTemplate::GuiWindowTemplate() - :MaximizedBoxOption_(BoolOption::Customizable) - , MinimizedBoxOption_(BoolOption::Customizable) - , BorderOption_(BoolOption::Customizable) - , SizeBoxOption_(BoolOption::Customizable) - , IconVisibleOption_(BoolOption::Customizable) - , TitleBarOption_(BoolOption::Customizable) - , MaximizedBox_(true) - , MinimizedBox_(true) - , Border_(true) - , SizeBox_(true) - , IconVisible_(true) - , TitleBar_(true) - , CustomizedBorder_(false) - , Maximized_(false) - , CustomFrameEnabled_(true) - { - GuiWindowTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiWindowTemplate::~GuiWindowTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiButtonTemplate -***********************************************************************/ - - GuiButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiButtonTemplate::GuiButtonTemplate() - :State_(ButtonState::Normal) - { - GuiButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiButtonTemplate::~GuiButtonTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiSelectableButtonTemplate -***********************************************************************/ - - GuiSelectableButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiSelectableButtonTemplate::GuiSelectableButtonTemplate() - :Selected_(false) - { - GuiSelectableButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiSelectableButtonTemplate::~GuiSelectableButtonTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiToolstripButtonTemplate -***********************************************************************/ - - GuiToolstripButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiToolstripButtonTemplate::GuiToolstripButtonTemplate() - :SubMenuExisting_(false) - , SubMenuOpening_(false) - , SubMenuHost_(0) - { - GuiToolstripButtonTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiToolstripButtonTemplate::~GuiToolstripButtonTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiListViewColumnHeaderTemplate -***********************************************************************/ - - GuiListViewColumnHeaderTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiListViewColumnHeaderTemplate::GuiListViewColumnHeaderTemplate() - :SortingState_(ColumnSortingState::NotSorted) - { - GuiListViewColumnHeaderTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiListViewColumnHeaderTemplate::~GuiListViewColumnHeaderTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiComboBoxTemplate -***********************************************************************/ - - GuiComboBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiComboBoxTemplate::GuiComboBoxTemplate() - :Commands_(nullptr) - , TextVisible_(true) - { - GuiComboBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiComboBoxTemplate::~GuiComboBoxTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiScrollTemplate -***********************************************************************/ - - GuiScrollTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiScrollTemplate::GuiScrollTemplate() - :Commands_(nullptr) - , TotalSize_(100) - , PageSize_(10) - , Position_(0) - { - GuiScrollTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiScrollTemplate::~GuiScrollTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiScrollViewTemplate -***********************************************************************/ - - void GuiScrollViewTemplate::UpdateTable() - { - if (horizontalScroll->GetEnabled() || horizontalAlwaysVisible) + DataEditorFactory::DataEditorFactory(TemplateProperty _templateFactory) + :templateFactory(_templateFactory) { - tableComposition->SetRowOption(1, GuiCellOption::AbsoluteOption(GetDefaultScrollSize())); - } - else - { - tableComposition->SetRowOption(1, GuiCellOption::AbsoluteOption(0)); - } - if (verticalScroll->GetEnabled() || verticalAlwaysVisible) - { - tableComposition->SetColumnOption(1, GuiCellOption::AbsoluteOption(GetDefaultScrollSize())); - } - else - { - tableComposition->SetColumnOption(1, GuiCellOption::AbsoluteOption(0)); - } - tableComposition->UpdateCellBounds(); - } - - GuiScrollViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiScrollViewTemplate::GuiScrollViewTemplate() - :DefaultScrollSize_(0) - , Commands_(nullptr) - { - GuiScrollViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiScrollViewTemplate::~GuiScrollViewTemplate() - { - FinalizeAggregation(); - } - - void GuiScrollViewTemplate::AdjustView(Size fullSize) - { - Size viewSize = containerComposition->GetBounds().GetSize(); - if (fullSize.x <= viewSize.x) - { - horizontalScroll->SetEnabled(false); - horizontalScroll->SetPosition(0); - } - else - { - horizontalScroll->SetEnabled(true); - horizontalScroll->SetTotalSize(fullSize.x); - horizontalScroll->SetPageSize(viewSize.x); - } - if (fullSize.y <= viewSize.y) - { - verticalScroll->SetEnabled(false); - verticalScroll->SetPosition(0); - } - else - { - verticalScroll->SetEnabled(true); - verticalScroll->SetTotalSize(fullSize.y); - verticalScroll->SetPageSize(viewSize.y); - } - UpdateTable(); - } - - GuiScroll* GuiScrollViewTemplate::GetHorizontalScroll() - { - return horizontalScroll; - } - - GuiScroll* GuiScrollViewTemplate::GetVerticalScroll() - { - return verticalScroll; - } - - bool GuiScrollViewTemplate::GetHorizontalAlwaysVisible() - { - return horizontalAlwaysVisible; - } - - void GuiScrollViewTemplate::SetHorizontalAlwaysVisible(bool value) - { - if (horizontalAlwaysVisible != value) - { - horizontalAlwaysVisible = value; - Commands_->CalculateView(); - } - } - - bool GuiScrollViewTemplate::GetVerticalAlwaysVisible() - { - return verticalAlwaysVisible; - } - - void GuiScrollViewTemplate::SetVerticalAlwaysVisible(bool value) - { - if (verticalAlwaysVisible != value) - { - verticalAlwaysVisible = value; - Commands_->CalculateView(); - } - } - - void GuiScrollViewTemplate::Initialize() - { - SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - - horizontalScroll = new GuiScroll(theme::ThemeName::HScroll); - horizontalScroll->SetControlTemplate(GetHScrollTemplate()); - horizontalScroll->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); - horizontalScroll->SetEnabled(false); - verticalScroll = new GuiScroll(theme::ThemeName::HScroll); - verticalScroll->SetControlTemplate(GetVScrollTemplate()); - verticalScroll->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); - verticalScroll->SetEnabled(false); - - tableComposition = new GuiTableComposition; - AddChild(tableComposition); - tableComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); - tableComposition->SetRowsAndColumns(2, 2); - tableComposition->SetRowOption(0, GuiCellOption::PercentageOption(1.0)); - tableComposition->SetRowOption(1, GuiCellOption::MinSizeOption()); - tableComposition->SetColumnOption(0, GuiCellOption::PercentageOption(1.0)); - tableComposition->SetColumnOption(1, GuiCellOption::MinSizeOption()); - UpdateTable(); - { - GuiCellComposition* cell = new GuiCellComposition; - tableComposition->AddChild(cell); - cell->SetSite(1, 0, 1, 1); - cell->AddChild(horizontalScroll->GetBoundsComposition()); - } - { - GuiCellComposition* cell = new GuiCellComposition; - tableComposition->AddChild(cell); - cell->SetSite(0, 1, 1, 1); - cell->AddChild(verticalScroll->GetBoundsComposition()); } - containerCellComposition = new GuiCellComposition; - tableComposition->AddChild(containerCellComposition); - containerCellComposition->SetSite(0, 0, 1, 1); - - containerComposition = new GuiBoundsComposition; - containerComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); - containerCellComposition->AddChild(containerComposition); - SetContainerComposition(containerComposition); - } - -/*********************************************************************** -GuiMultilineTextBoxTemplate -***********************************************************************/ - - GuiMultilineTextBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiMultilineTextBoxTemplate::GuiMultilineTextBoxTemplate() - :Commands_(nullptr) - { - GuiMultilineTextBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiMultilineTextBoxTemplate::~GuiMultilineTextBoxTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiListControlTemplate -***********************************************************************/ - - GuiListControlTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiListControlTemplate::GuiListControlTemplate() - { - GuiListControlTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiListControlTemplate::~GuiListControlTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiTextListTemplate -***********************************************************************/ - - GuiTextListTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiTextListTemplate::GuiTextListTemplate() - { - GuiTextListTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiTextListTemplate::~GuiTextListTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiDocumentViewerTemplate -***********************************************************************/ - - GuiDocumentViewerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiDocumentViewerTemplate::GuiDocumentViewerTemplate() - { - GuiDocumentViewerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiDocumentViewerTemplate::~GuiDocumentViewerTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiListViewTemplate -***********************************************************************/ - - GuiListViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiListViewTemplate::GuiListViewTemplate() - { - GuiListViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiListViewTemplate::~GuiListViewTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiTreeViewTemplate -***********************************************************************/ - - GuiTreeViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiTreeViewTemplate::GuiTreeViewTemplate() - { - GuiTreeViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiTreeViewTemplate::~GuiTreeViewTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiTabTemplate -***********************************************************************/ - - GuiTabTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiTabTemplate::GuiTabTemplate() - :Commands_(nullptr) - , SelectedTabPage_(nullptr) - { - GuiTabTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiTabTemplate::~GuiTabTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiDatePickerTemplate -***********************************************************************/ - - vint GetDayCountForMonth(vint year, vint month) - { - bool isLeapYear = (year % 100 == 0) ? (year % 400 == 0) : (year % 4 == 0); - switch (month) + DataEditorFactory::~DataEditorFactory() { - case 1:case 3:case 5:case 7:case 8:case 10:case 12: - return 31; - case 4:case 6:case 9:case 11: - return 30; - default: - return isLeapYear ? 29 : 28; } - } - void StepPreviousMonth(vint& year, vint& month) - { - if (month == 1) + Ptr DataEditorFactory::CreateEditor(controls::list::IDataGridContext* dataGridContext) { - year--; - month = 12; - } - else - { - month--; - } - } + auto editor = MakePtr(); + editor->factory = this; + editor->dataGridContext = dataGridContext; - void StepNextMonth(vint& year, vint& month) - { - if (month == 12) - { - year++; - month = 1; + ItemTemplate* itemTemplate = templateFactory(dataGridContext->GetViewModelContext()); + CHECK_ERROR(itemTemplate, L"DataEditorFactory::CreateEditor(IDataGridContext*)#An instance of GuiGridEditorTemplate is expected."); + editor->editorTemplate = itemTemplate; + return editor; } - else + +/*********************************************************************** +MainColumnVisualizerTemplate +***********************************************************************/ + + void MainColumnVisualizerTemplate::OnTextChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - month++; + text->SetText(GetText()); } - } - void GuiDatePickerTemplate::SetDay(const DateTime& day, vint& index, bool currentMonth) - { - dateDays[index] = day; - GuiSolidLabelElement* label = labelDays[index]; - label->SetText(itow(day.day)); - label->SetColor(currentMonth ? GetPrimaryTextColor() : GetSecondaryTextColor()); - index++; - } - - void GuiDatePickerTemplate::comboYearMonth_SelectedIndexChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if (!preventComboEvent) + void MainColumnVisualizerTemplate::OnFontChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - if (comboYear->GetSelectedIndex() != -1 && comboMonth->GetSelectedIndex() != -1) + text->SetFont(GetFont()); + } + + void MainColumnVisualizerTemplate::OnTextColorChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + text->SetColor(GetPrimaryTextColor()); + } + + void MainColumnVisualizerTemplate::OnSmallImageChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + auto imageData = GetSmallImage(); + if (imageData) { - vint year = comboYear->GetSelectedIndex() + YearFirst; - vint month = comboMonth->GetSelectedIndex() + 1; - SetDate(DateTime::FromDateTime(year, month, 1)); - Commands_->NotifyDateChanged(); - Commands_->NotifyDateNavigated(); + image->SetImage(imageData->GetImage(), imageData->GetFrameIndex()); + } + else + { + image->SetImage(nullptr); } } - } - void GuiDatePickerTemplate::buttonDay_SelectedChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if (!preventButtonEvent) + MainColumnVisualizerTemplate::MainColumnVisualizerTemplate() { - GuiSelectableButton* button = dynamic_cast(sender->GetRelatedControl()); - if (button->GetSelected()) - { - vint index = buttonDays.IndexOf(button); - if (index != -1) - { - DateTime day = dateDays[index]; - if (day.year != currentDate.year || day.month != currentDate.month) - { - SetDate(day); - } - else - { - currentDate = day; - } - Commands_->NotifyDateChanged(); - Commands_->NotifyDateSelected(); - } - } - } - } - - void GuiDatePickerTemplate::DisplayMonth(vint year, vint month) - { - if (YearFirst <= year && year <= YearLast && 1 <= month && month <= 12) - { - preventComboEvent = true; - comboYear->SetSelectedIndex(year - YearFirst); - comboMonth->SetSelectedIndex(month - 1); - preventComboEvent = false; - } - - vint yearPrev = year, yearNext = year, monthPrev = month, monthNext = month; - StepPreviousMonth(yearPrev, monthPrev); - StepNextMonth(yearNext, monthNext); - - vint countPrev = GetDayCountForMonth(yearPrev, monthPrev); - vint count = GetDayCountForMonth(year, month); - vint countNext = GetDayCountForMonth(yearNext, monthNext); - - DateTime firstDay = DateTime::FromDateTime(year, month, 1); - vint showPrev = firstDay.dayOfWeek; - if (showPrev == 0) showPrev = DaysOfWeek; - vint show = count; - vint showNext = DaysOfWeek*DayRows - showPrev - show; - - vint index = 0; - for (vint i = 0; i < showPrev; i++) - { - DateTime day = DateTime::FromDateTime(yearPrev, monthPrev, countPrev - (showPrev - i - 1)); - SetDay(day, index, false); - } - for (vint i = 0; i < show; i++) - { - DateTime day = DateTime::FromDateTime(year, month, i + 1); - SetDay(day, index, true); - } - for (vint i = 0; i < showNext; i++) - { - DateTime day = DateTime::FromDateTime(yearNext, monthNext, i + 1); - SetDay(day, index, false); - } - } - - void GuiDatePickerTemplate::SelectDay(vint day) - { - for (vint i = 0; i < dateDays.Count(); i++) - { - const DateTime& dt = dateDays[i]; - if (dt.year == currentDate.year && dt.month == currentDate.month && dt.day == day) - { - preventButtonEvent = true; - buttonDays[i]->SetSelected(true); - preventButtonEvent = false; - break; - } - } - } - - void GuiDatePickerTemplate::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - auto value = GetFont(); - comboYear->SetFont(value); - listYears->SetFont(value); - comboMonth->SetFont(value); - listMonths->SetFont(value); - FOREACH(GuiSolidLabelElement*, label, From(labelDaysOfWeek).Concat(labelDays)) - { - label->SetFont(value); - } - } - - void GuiDatePickerTemplate::UpdateData(const DateTime& value, bool forceUpdate) - { - bool dateChanged = currentDate.year != value.year || currentDate.month != value.month || currentDate.day != value.day; - - if (forceUpdate || dateChanged) - { - currentDate = value; - DisplayMonth(value.year, value.month); - SelectDay(value.day); - } - - if (dateChanged) - { - GuiEventArgs arguments(this); - DateChanged.Execute(arguments); - } - } - - GuiDatePickerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiDatePickerTemplate::GuiDatePickerTemplate() - :Commands_(nullptr) - , preventComboEvent(false) - , preventButtonEvent(false) - { - CommandsChanged.SetAssociatedComposition(this); - DateLocaleChanged.SetAssociatedComposition(this); - DateChanged.SetAssociatedComposition(this); - GuiDatePickerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiDatePickerTemplate::~GuiDatePickerTemplate() - { - FinalizeAggregation(); - } - - const Locale& GuiDatePickerTemplate::GetDateLocale() - { - return dateLocale; - } - - void GuiDatePickerTemplate::SetDateLocale(const Locale& value) - { - if (dateLocale != value) - { - dateLocale = value; - for (vint i = 0; i < DaysOfWeek; i++) - { - labelDaysOfWeek[i]->SetText(dateLocale.GetShortDayOfWeekName(i)); - } - - listMonths->GetItems().Clear(); - for (vint i = 1; i <= 12; i++) - { - listMonths->GetItems().Add(new list::TextItem(dateLocale.GetLongMonthName(i))); - } - - UpdateData(currentDate, true); - - GuiEventArgs arguments(this); - DateLocaleChanged.Execute(arguments); - } - } - - const DateTime& GuiDatePickerTemplate::GetDate() - { - return currentDate; - } - - void GuiDatePickerTemplate::SetDate(const DateTime& value) - { - UpdateData(value, false); - } - - void GuiDatePickerTemplate::Initialize() - { - GuiTableComposition* monthTable = 0; - GuiTableComposition* dayTable = 0; - { - listYears = new GuiTextList(theme::ThemeName::TextList); - listYears->SetControlTemplate(GetDateTextListTemplate()); - listYears->SetHorizontalAlwaysVisible(false); - for (vint i = YearFirst; i <= YearLast; i++) - { - listYears->GetItems().Add(new list::TextItem(itow(i))); - } - comboYear = new GuiComboBoxListControl(theme::ThemeName::ComboBox, listYears); - comboYear->SetControlTemplate(GetDateComboBoxTemplate()); - comboYear->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 2, 0)); - comboYear->SelectedIndexChanged.AttachMethod(this, &GuiDatePickerTemplate::comboYearMonth_SelectedIndexChanged); - } - { - listMonths = new GuiTextList(theme::ThemeName::TextList); - listMonths->SetControlTemplate(GetDateTextListTemplate()); - listMonths->SetHorizontalAlwaysVisible(false); - comboMonth = new GuiComboBoxListControl(theme::ThemeName::ComboBox, listMonths); - comboMonth->SetControlTemplate(GetDateComboBoxTemplate()); - comboMonth->GetBoundsComposition()->SetAlignmentToParent(Margin(2, 0, 0, 0)); - comboMonth->SelectedIndexChanged.AttachMethod(this, &GuiDatePickerTemplate::comboYearMonth_SelectedIndexChanged); - } - { - monthTable = new GuiTableComposition; - monthTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); - monthTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - monthTable->SetRowsAndColumns(1, 2); - monthTable->SetRowOption(0, GuiCellOption::MinSizeOption()); - monthTable->SetColumnOption(0, GuiCellOption::PercentageOption(0.5)); - monthTable->SetColumnOption(1, GuiCellOption::PercentageOption(0.5)); + GuiTableComposition* table = new GuiTableComposition; + table->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + table->SetRowsAndColumns(3, 2); + table->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); + table->SetRowOption(1, GuiCellOption::MinSizeOption()); + table->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); + table->SetColumnOption(0, GuiCellOption::MinSizeOption()); + table->SetColumnOption(1, GuiCellOption::PercentageOption(1.0)); + table->SetCellPadding(2); { GuiCellComposition* cell = new GuiCellComposition; - monthTable->AddChild(cell); - cell->SetSite(0, 0, 1, 1); - cell->AddChild(comboYear->GetBoundsComposition()); + table->AddChild(cell); + cell->SetSite(1, 0, 1, 1); + cell->SetPreferredMinSize(Size(16, 16)); + + image = GuiImageFrameElement::Create(); + image->SetStretch(true); + cell->SetOwnedElement(image); } { GuiCellComposition* cell = new GuiCellComposition; - monthTable->AddChild(cell); - cell->SetSite(0, 1, 1, 1); - cell->AddChild(comboMonth->GetBoundsComposition()); + table->AddChild(cell); + cell->SetSite(0, 1, 3, 1); + cell->SetMargin(Margin(0, 0, 8, 0)); + + text = GuiSolidLabelElement::Create(); + text->SetAlignments(Alignment::Left, Alignment::Center); + text->SetEllipse(true); + cell->SetOwnedElement(text); } + table->SetAlignmentToParent(Margin(0, 0, 0, 0)); + + SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + AddChild(table); + + TextChanged.AttachMethod(this, &MainColumnVisualizerTemplate::OnTextChanged); + FontChanged.AttachMethod(this, &MainColumnVisualizerTemplate::OnFontChanged); + PrimaryTextColorChanged.AttachMethod(this, &MainColumnVisualizerTemplate::OnTextColorChanged); + SmallImageChanged.AttachMethod(this, &MainColumnVisualizerTemplate::OnSmallImageChanged); + + TextChanged.Execute(compositions::GuiEventArgs(this)); + FontChanged.Execute(compositions::GuiEventArgs(this)); + PrimaryTextColorChanged.Execute(compositions::GuiEventArgs(this)); + SmallImageChanged.Execute(compositions::GuiEventArgs(this)); } + + MainColumnVisualizerTemplate::~MainColumnVisualizerTemplate() { - dayTable = new GuiTableComposition; - dayTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - dayTable->SetCellPadding(4); - dayTable->SetRowsAndColumns(DayRows + DayRowStart, DaysOfWeek); - - for (vint i = 0; i < DayRowStart; i++) - { - dayTable->SetRowOption(i, GuiCellOption::MinSizeOption()); - } - for (vint i = 0; i < DayRows; i++) - { - dayTable->SetRowOption(i + DayRowStart, GuiCellOption::PercentageOption(1.0)); - } - for (vint i = 0; i < DaysOfWeek; i++) - { - dayTable->SetColumnOption(i, GuiCellOption::PercentageOption(1.0)); - } - - { - GuiCellComposition* cell = new GuiCellComposition; - dayTable->AddChild(cell); - cell->SetSite(0, 0, 1, DaysOfWeek); - cell->AddChild(monthTable); - } - - labelDaysOfWeek.Resize(7); - for (vint i = 0; i < DaysOfWeek; i++) - { - GuiCellComposition* cell = new GuiCellComposition; - dayTable->AddChild(cell); - cell->SetSite(1, i, 1, 1); - - GuiSolidLabelElement* element = GuiSolidLabelElement::Create(); - element->SetAlignments(Alignment::Center, Alignment::Center); - element->SetColor(GetPrimaryTextColor()); - labelDaysOfWeek[i] = element; - cell->SetOwnedElement(element); - } - - buttonDays.Resize(DaysOfWeek*DayRows); - labelDays.Resize(DaysOfWeek*DayRows); - dateDays.Resize(DaysOfWeek*DayRows); - - auto dayMutexController = new GuiSelectableButton::MutexGroupController; - AddComponent(dayMutexController); - - for (vint i = 0; i < DaysOfWeek; i++) - { - for (vint j = 0; j < DayRows; j++) - { - GuiCellComposition* cell = new GuiCellComposition; - dayTable->AddChild(cell); - cell->SetSite(j + DayRowStart, i, 1, 1); - - GuiSelectableButton* button = new GuiSelectableButton(theme::ThemeName::CheckBox); - button->SetControlTemplate(GetDateButtonTemplate()); - button->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); - button->SetGroupController(dayMutexController); - button->SelectedChanged.AttachMethod(this, &GuiDatePickerTemplate::buttonDay_SelectedChanged); - cell->AddChild(button->GetBoundsComposition()); - buttonDays[j*DaysOfWeek + i] = button; - - GuiSolidLabelElement* element = GuiSolidLabelElement::Create(); - element->SetAlignments(Alignment::Center, Alignment::Center); - element->SetText(L"0"); - labelDays[j*DaysOfWeek + i] = element; - - GuiBoundsComposition* elementBounds = new GuiBoundsComposition; - elementBounds->SetOwnedElement(element); - elementBounds->SetAlignmentToParent(Margin(0, 0, 0, 0)); - elementBounds->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElement); - button->GetContainerComposition()->AddChild(elementBounds); - } - } } + +/*********************************************************************** +SubColumnVisualizerTemplate +***********************************************************************/ + + void SubColumnVisualizerTemplate::OnTextChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - GuiSolidBackgroundElement* element = GuiSolidBackgroundElement::Create(); - element->SetColor(GetBackgroundColor()); - dayTable->SetOwnedElement(element); + text->SetText(GetText()); } - dayTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); - AddChild(dayTable); + void SubColumnVisualizerTemplate::OnFontChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + text->SetFont(GetFont()); + } - SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - SetContainerComposition(this); - } + void SubColumnVisualizerTemplate::OnTextColorChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + text->SetColor(GetSecondaryTextColor()); + } + void SubColumnVisualizerTemplate::Initialize(bool fixTextColor) + { + text = GuiSolidLabelElement::Create(); + text->SetVerticalAlignment(Alignment::Center); + + SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + SetMargin(Margin(8, 0, 8, 0)); + SetOwnedElement(text); + + TextChanged.AttachMethod(this, &SubColumnVisualizerTemplate::OnTextChanged); + FontChanged.AttachMethod(this, &SubColumnVisualizerTemplate::OnFontChanged); + if (!fixTextColor) + { + SecondaryTextColorChanged.AttachMethod(this, &SubColumnVisualizerTemplate::OnTextColorChanged); + } + + TextChanged.Execute(compositions::GuiEventArgs(this)); + FontChanged.Execute(compositions::GuiEventArgs(this)); + if (!fixTextColor) + { + SecondaryTextColorChanged.Execute(compositions::GuiEventArgs(this)); + } + } + + SubColumnVisualizerTemplate::SubColumnVisualizerTemplate(bool fixTextColor) + { + Initialize(fixTextColor); + } + + SubColumnVisualizerTemplate::SubColumnVisualizerTemplate() + { + Initialize(false); + } + + SubColumnVisualizerTemplate::~SubColumnVisualizerTemplate() + { + } + /*********************************************************************** -GuiDateComboBoxTemplate +HyperlinkVisualizerTemplate ***********************************************************************/ - GuiDateComboBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + void HyperlinkVisualizerTemplate::label_MouseEnter(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + FontProperties font = text->GetFont(); + font.underline = true; + text->SetFont(font); + } - GuiDateComboBoxTemplate::GuiDateComboBoxTemplate() - { - GuiDateComboBoxTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } + void HyperlinkVisualizerTemplate::label_MouseLeave(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + FontProperties font = text->GetFont(); + font.underline = false; + text->SetFont(font); + } - GuiDateComboBoxTemplate::~GuiDateComboBoxTemplate() - { - FinalizeAggregation(); - } + HyperlinkVisualizerTemplate::HyperlinkVisualizerTemplate() + :SubColumnVisualizerTemplate(true) + { + text->SetColor(Color(0, 0, 255)); + text->SetEllipse(true); + GetEventReceiver()->mouseEnter.AttachMethod(this, &HyperlinkVisualizerTemplate::label_MouseEnter); + GetEventReceiver()->mouseLeave.AttachMethod(this, &HyperlinkVisualizerTemplate::label_MouseLeave); + SetAssociatedCursor(GetCurrentController()->ResourceService()->GetSystemCursor(INativeCursor::Hand)); + } + HyperlinkVisualizerTemplate::~HyperlinkVisualizerTemplate() + { + } + /*********************************************************************** -GuiListItemTemplate +CellBorderVisualizerTemplate ***********************************************************************/ - void GuiListItemTemplate::OnInitialize() - { - CHECK_ERROR(initialized == false, L"GuiListItemTemplate::OnInitialize()#Cannot initialize a GuiListItemTemplate twice."); - } + void CellBorderVisualizerTemplate::OnItemSeparatorColorChanged(GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + border1->SetColor(GetItemSeparatorColor()); + border2->SetColor(GetItemSeparatorColor()); + } - GuiListItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) + CellBorderVisualizerTemplate::CellBorderVisualizerTemplate() + { + GuiBoundsComposition* bounds1 = nullptr; + GuiBoundsComposition* bounds2 = nullptr; + { + border1 = GuiSolidBorderElement::Create(); - GuiListItemTemplate::GuiListItemTemplate() - :Selected_(false) - , Index_(0) - { - GuiListItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } + bounds1 = new GuiBoundsComposition; + bounds1->SetOwnedElement(border1); + bounds1->SetAlignmentToParent(Margin(-1, 0, 0, 0)); + } + { + border2 = GuiSolidBorderElement::Create(); - GuiListItemTemplate::~GuiListItemTemplate() - { - FinalizeAggregation(); - } + bounds2 = new GuiBoundsComposition; + bounds2->SetOwnedElement(border2); + bounds2->SetAlignmentToParent(Margin(0, -1, 0, 0)); + } - void GuiListItemTemplate::BeginEditListItem() - { - listControl->GetItemProvider()->PushEditing(); - } + SetAlignmentToParent(Margin(0, 0, 1, 1)); + SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + AddChild(bounds1); + AddChild(bounds2); - void GuiListItemTemplate::EndEditListItem() - { - CHECK_ERROR(listControl->GetItemProvider()->PopEditing(), L"GuiListItemTemplate::EndEditListItem()#BeginEditListItem and EndEditListItem calls are not paired."); - } + ItemSeparatorColorChanged.AttachMethod(this, &CellBorderVisualizerTemplate::OnItemSeparatorColorChanged); - void GuiListItemTemplate::Initialize(controls::GuiListControl* _listControl) - { - CHECK_ERROR(listControl == nullptr, L"GuiListItemTemplate::Initialize(GuiListControl*)#This function can only be called once."); - listControl = _listControl; - OnInitialize(); - } + ItemSeparatorColorChanged.Execute(compositions::GuiEventArgs(this)); + } -/*********************************************************************** -GuiTextListItemTemplate -***********************************************************************/ - - GuiTextListItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiTextListItemTemplate::GuiTextListItemTemplate() - { - GuiTextListItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiTextListItemTemplate::~GuiTextListItemTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiTreeItemTemplate -***********************************************************************/ - - GuiTreeItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiTreeItemTemplate::GuiTreeItemTemplate() - :Expanding_(false) - , Expandable_(false) - , Level_(0) - { - GuiTreeItemTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiTreeItemTemplate::~GuiTreeItemTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiGridCellTemplate -***********************************************************************/ - - GuiGridCellTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiGridCellTemplate::GuiGridCellTemplate() - { - GuiGridCellTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiGridCellTemplate::~GuiGridCellTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiGridVisualizerTemplate -***********************************************************************/ - - GuiGridVisualizerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiGridVisualizerTemplate::GuiGridVisualizerTemplate() - { - GuiGridVisualizerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiGridVisualizerTemplate::~GuiGridVisualizerTemplate() - { - FinalizeAggregation(); - } - -/*********************************************************************** -GuiGridEditorTemplate -***********************************************************************/ - - GuiGridEditorTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_IMPL) - - GuiGridEditorTemplate::GuiGridEditorTemplate() - :CellValueSaved_(true) - , FocusControl_(nullptr) - { - GuiGridEditorTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_EVENT_INIT) - } - - GuiGridEditorTemplate::~GuiGridEditorTemplate() - { - FinalizeAggregation(); + CellBorderVisualizerTemplate::~CellBorderVisualizerTemplate() + { + } } } } @@ -24232,7 +23368,7 @@ GuiTextBoxAutoCompleteBase } /*********************************************************************** -.\CONTROLS\TOOLSTRIPPACKAGE\GUIMENUCONTROLS.CPP +.\CONTROLS\TEXTEDITORPACKAGE\GUITEXTCOMMONINTERFACE.CPP ***********************************************************************/ namespace vl @@ -24241,442 +23377,549 @@ namespace vl { namespace controls { + using namespace elements; + using namespace elements::text; using namespace compositions; /*********************************************************************** -IGuiMenuService +GuiTextBoxCommonInterface::DefaultCallback ***********************************************************************/ - const wchar_t* const IGuiMenuService::Identifier = L"vl::presentation::controls::IGuiMenuService"; - - IGuiMenuService::IGuiMenuService() - :openingMenu(0) + GuiTextBoxCommonInterface::DefaultCallback::DefaultCallback(elements::GuiColorizedTextElement* _textElement, compositions::GuiGraphicsComposition* _textComposition) + :textElement(_textElement) + ,textComposition(_textComposition) { } - void IGuiMenuService::MenuItemExecuted() - { - if(openingMenu) - { - openingMenu->Hide(); - } - if(GetParentMenuService()) - { - GetParentMenuService()->MenuItemExecuted(); - } - } - - GuiMenu* IGuiMenuService::GetOpeningMenu() - { - return openingMenu; - } - - void IGuiMenuService::MenuOpened(GuiMenu* menu) - { - if(openingMenu!=menu && openingMenu) - { - openingMenu->Hide(); - } - openingMenu=menu; - } - - void IGuiMenuService::MenuClosed(GuiMenu* menu) - { - if(openingMenu==menu) - { - openingMenu=0; - } - } - -/*********************************************************************** -GuiMenu -***********************************************************************/ - - void GuiMenu::BeforeControlTemplateUninstalled_() + GuiTextBoxCommonInterface::DefaultCallback::~DefaultCallback() { } - void GuiMenu::AfterControlTemplateInstalled_(bool initialize) + TextPos GuiTextBoxCommonInterface::DefaultCallback::GetLeftWord(TextPos pos) { + return pos; } - IGuiMenuService* GuiMenu::GetParentMenuService() + TextPos GuiTextBoxCommonInterface::DefaultCallback::GetRightWord(TextPos pos) { - return parentMenuService; + return pos; } - IGuiMenuService::Direction GuiMenu::GetPreferredDirection() + void GuiTextBoxCommonInterface::DefaultCallback::GetWord(TextPos pos, TextPos& begin, TextPos& end) { - return IGuiMenuService::Vertical; + begin=pos; + end=pos; } - bool GuiMenu::IsActiveState() + vint GuiTextBoxCommonInterface::DefaultCallback::GetPageRows() + { + return textComposition->GetBounds().Height()/textElement->GetLines().GetRowHeight(); + } + + bool GuiTextBoxCommonInterface::DefaultCallback::BeforeModify(TextPos start, TextPos end, const WString& originalText, WString& inputText) { return true; } - bool GuiMenu::IsSubMenuActivatedByMouseDown() +/*********************************************************************** +GuiTextBoxCommonInterface +***********************************************************************/ + + void GuiTextBoxCommonInterface::InvokeUndoRedoChanged() { + UndoRedoChanged.Execute(textControl->GetNotifyEventArguments()); + } + + void GuiTextBoxCommonInterface::InvokeModifiedChanged() + { + ModifiedChanged.Execute(textControl->GetNotifyEventArguments()); + } + + void GuiTextBoxCommonInterface::UpdateCaretPoint() + { + GuiGraphicsHost* host=textComposition->GetRelatedGraphicsHost(); + if(host) + { + Rect caret=textElement->GetLines().GetRectFromTextPos(textElement->GetCaretEnd()); + Point view=textElement->GetViewPosition(); + vint x=caret.x1-view.x; + vint y=caret.y2-view.y; + host->SetCaretPoint(Point(x, y), textComposition); + } + } + + void GuiTextBoxCommonInterface::Move(TextPos pos, bool shift) + { + TextPos oldBegin=textElement->GetCaretBegin(); + TextPos oldEnd=textElement->GetCaretEnd(); + + pos=textElement->GetLines().Normalize(pos); + if(!shift) + { + textElement->SetCaretBegin(pos); + } + textElement->SetCaretEnd(pos); + if(textControl) + { + GuiGraphicsHost* host=textComposition->GetRelatedGraphicsHost(); + if(host) + { + if(host->GetFocusedComposition()==textControl->GetFocusableComposition()) + { + textElement->SetCaretVisible(true); + } + } + } + + Rect bounds=textElement->GetLines().GetRectFromTextPos(pos); + Rect view=Rect(textElement->GetViewPosition(), textComposition->GetBounds().GetSize()); + Point viewPoint=view.LeftTop(); + + if(view.x2>view.x1 && view.y2>view.y1) + { + if(bounds.x1view.x2) + { + viewPoint.x=bounds.x2-view.Width(); + } + if(bounds.y1view.y2) + { + viewPoint.y=bounds.y2-view.Height(); + } + } + + callback->ScrollToView(viewPoint); + UpdateCaretPoint(); + + TextPos newBegin=textElement->GetCaretBegin(); + TextPos newEnd=textElement->GetCaretEnd(); + if(oldBegin!=newBegin || oldEnd!=newEnd) + { + ICommonTextEditCallback::TextCaretChangedStruct arguments; + arguments.oldBegin=oldBegin; + arguments.oldEnd=oldEnd; + arguments.newBegin=newBegin; + arguments.newEnd=newEnd; + arguments.editVersion=editVersion; + for(vint i=0;iTextCaretChanged(arguments); + } + SelectionChanged.Execute(textControl->GetNotifyEventArguments()); + } + } + + void GuiTextBoxCommonInterface::Modify(TextPos start, TextPos end, const WString& input, bool asKeyInput) + { + if(start>end) + { + TextPos temp=start; + start=end; + end=temp; + } + TextPos originalStart=start; + TextPos originalEnd=end; + WString originalText=textElement->GetLines().GetText(start, end); + WString inputText=input; + if(callback->BeforeModify(start, end, originalText, inputText)) + { + { + ICommonTextEditCallback::TextEditPreviewStruct arguments; + arguments.originalStart=originalStart; + arguments.originalEnd=originalEnd; + arguments.originalText=originalText; + arguments.inputText=inputText; + arguments.editVersion=editVersion; + arguments.keyInput=asKeyInput; + for(vint i=0;iTextEditPreview(arguments); + } + + inputText=arguments.inputText; + if(originalStart!=arguments.originalStart || originalEnd!=arguments.originalEnd) + { + originalStart=arguments.originalStart; + originalEnd=arguments.originalEnd; + originalText=textElement->GetLines().GetText(originalStart, originalEnd); + start=originalStart; + end=originalEnd; + } + } + + SPIN_LOCK(elementModifyLock) + { + end=textElement->GetLines().Modify(start, end, inputText); + } + callback->AfterModify(originalStart, originalEnd, originalText, start, end, inputText); + + editVersion++; + { + ICommonTextEditCallback::TextEditNotifyStruct arguments; + arguments.originalStart=originalStart; + arguments.originalEnd=originalEnd; + arguments.originalText=originalText; + arguments.inputStart=start; + arguments.inputEnd=end; + arguments.inputText=inputText; + arguments.editVersion=editVersion; + arguments.keyInput=asKeyInput; + for(vint i=0;iTextEditNotify(arguments); + } + } + + Move(end, false); + + for(vint i=0;iTextEditFinished(editVersion); + } + + textControl->TextChanged.Execute(textControl->GetNotifyEventArguments()); + } + } + + bool GuiTextBoxCommonInterface::ProcessKey(vint code, bool shift, bool ctrl) + { + if(IGuiShortcutKeyItem* item=internalShortcutKeyManager->TryGetShortcut(ctrl, shift, false, code)) + { + GuiEventArgs arguments; + item->Executed.Execute(arguments); + return true; + } + + TextPos begin=textElement->GetCaretBegin(); + TextPos end=textElement->GetCaretEnd(); + switch(code) + { + case VKEY_ESCAPE: + if(autoComplete && autoComplete->IsListOpening() && !shift && !ctrl) + { + autoComplete->CloseList(); + } + return true; + case VKEY_RETURN: + if(autoComplete && autoComplete->IsListOpening() && !shift && !ctrl) + { + if(autoComplete->ApplySelectedListItem()) + { + preventEnterDueToAutoComplete=true; + return true; + } + } + break; + case VKEY_UP: + if(autoComplete && autoComplete->IsListOpening() && !shift && !ctrl) + { + autoComplete->SelectPreviousListItem(); + } + else + { + end.row--; + Move(end, shift); + } + return true; + case VKEY_DOWN: + if(autoComplete && autoComplete->IsListOpening() && !shift && !ctrl) + { + autoComplete->SelectNextListItem(); + } + else + { + end.row++; + Move(end, shift); + } + return true; + case VKEY_LEFT: + { + if(ctrl) + { + Move(callback->GetLeftWord(end), shift); + } + else + { + if(end.column==0) + { + if(end.row>0) + { + end.row--; + end=textElement->GetLines().Normalize(end); + end.column=textElement->GetLines().GetLine(end.row).dataLength; + } + } + else + { + end.column--; + } + Move(end, shift); + } + } + return true; + case VKEY_RIGHT: + { + if(ctrl) + { + Move(callback->GetRightWord(end), shift); + } + else + { + if(end.column==textElement->GetLines().GetLine(end.row).dataLength) + { + if(end.rowGetLines().GetCount()-1) + { + end.row++; + end.column=0; + } + } + else + { + end.column++; + } + Move(end, shift); + } + } + return true; + case VKEY_HOME: + { + if(ctrl) + { + Move(TextPos(0, 0), shift); + } + else + { + end.column=0; + Move(end, shift); + } + } + return true; + case VKEY_END: + { + if(ctrl) + { + end.row=textElement->GetLines().GetCount()-1; + } + end.column=textElement->GetLines().GetLine(end.row).dataLength; + Move(end, shift); + } + return true; + case VKEY_PRIOR: + { + end.row-=callback->GetPageRows(); + Move(end, shift); + } + return true; + case VKEY_NEXT: + { + end.row+=callback->GetPageRows(); + Move(end, shift); + } + return true; + case VKEY_BACK: + if(!readonly) + { + if(ctrl && !shift) + { + ProcessKey(VKEY_LEFT, true, true); + ProcessKey(VKEY_BACK, false, false); + } + else if(!ctrl && shift) + { + ProcessKey(VKEY_UP, true, false); + ProcessKey(VKEY_BACK, false, false); + } + else + { + if(begin==end) + { + ProcessKey(VKEY_LEFT, true, false); + } + SetSelectionTextAsKeyInput(L""); + } + return true; + } + break; + case VKEY_DELETE: + if(!readonly) + { + if(ctrl && !shift) + { + ProcessKey(VKEY_RIGHT, true, true); + ProcessKey(VKEY_DELETE, false, false); + } + else if(!ctrl && shift) + { + ProcessKey(VKEY_DOWN, true, false); + ProcessKey(VKEY_DELETE, false, false); + } + else + { + if(begin==end) + { + ProcessKey(VKEY_RIGHT, true, false); + } + SetSelectionTextAsKeyInput(L""); + } + return true; + } + break; + } return false; } - void GuiMenu::MenuItemExecuted() + void GuiTextBoxCommonInterface::OnGotFocus(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - IGuiMenuService::MenuItemExecuted(); - Hide(); + textElement->SetFocused(true); + textElement->SetCaretVisible(true); + UpdateCaretPoint(); } - void GuiMenu::OnWindowOpened(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + void GuiTextBoxCommonInterface::OnLostFocus(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - if(parentMenuService) + textElement->SetFocused(false); + textElement->SetCaretVisible(false); + } + + void GuiTextBoxCommonInterface::OnCaretNotify(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + textElement->SetCaretVisible(!textElement->GetCaretVisible()); + } + + void GuiTextBoxCommonInterface::OnLeftButtonDown(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) + { + if(textControl->GetVisuallyEnabled() && arguments.compositionSource==arguments.eventSource) { - parentMenuService->MenuOpened(this); + dragging=true; + TextPos pos=GetNearestTextPos(Point(arguments.x, arguments.y)); + Move(pos, arguments.shift); } } - void GuiMenu::OnDeactivatedAltHost() + void GuiTextBoxCommonInterface::OnLeftButtonUp(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) { - Hide(); - } - - void GuiMenu::MouseClickedOnOtherWindow(GuiWindow* window) - { - GuiMenu* targetMenu=dynamic_cast(window); - if(!targetMenu) + if(textControl->GetVisuallyEnabled() && arguments.compositionSource==arguments.eventSource) { - Hide(); + dragging=false; } } - void GuiMenu::OnWindowClosed(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + void GuiTextBoxCommonInterface::OnMouseMove(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) { - if(parentMenuService) + if(textControl->GetVisuallyEnabled() && arguments.compositionSource==arguments.eventSource) { - parentMenuService->MenuClosed(this); - GuiMenu* openingSubMenu=GetOpeningMenu(); - if(openingSubMenu) + if(dragging) { - openingSubMenu->Hide(); + TextPos pos=GetNearestTextPos(Point(arguments.x, arguments.y)); + Move(pos, true); } } } - GuiMenu::GuiMenu(theme::ThemeName themeName, GuiControl* _owner) - :GuiPopup(themeName) - , owner(_owner) - , parentMenuService(0) + void GuiTextBoxCommonInterface::OnKeyDown(compositions::GuiGraphicsComposition* sender, compositions::GuiKeyEventArgs& arguments) { - GetNativeWindow()->SetAlwaysPassFocusToParent(true); - UpdateMenuService(); - WindowOpened.AttachMethod(this, &GuiMenu::OnWindowOpened); - WindowClosed.AttachMethod(this, &GuiMenu::OnWindowClosed); - } - - GuiMenu::~GuiMenu() - { - } - - void GuiMenu::UpdateMenuService() - { - if(owner) + if(textControl->GetVisuallyEnabled() && arguments.compositionSource==arguments.eventSource) { - parentMenuService=owner->QueryTypedService(); + if(ProcessKey(arguments.code, arguments.shift, arguments.ctrl)) + { + arguments.handled=true; + } } } - IDescriptable* GuiMenu::QueryService(const WString& identifier) + void GuiTextBoxCommonInterface::OnCharInput(compositions::GuiGraphicsComposition* sender, compositions::GuiCharEventArgs& arguments) { - if(identifier==IGuiMenuService::Identifier) + if(preventEnterDueToAutoComplete) { - return (IGuiMenuService*)this; + preventEnterDueToAutoComplete=false; + if(arguments.code==VKEY_RETURN) + { + return; + } + } + if(textControl->GetVisuallyEnabled() && arguments.compositionSource==arguments.eventSource) + { + if(!readonly && arguments.code!=VKEY_ESCAPE && arguments.code!=VKEY_BACK && !arguments.ctrl) + { + SetSelectionTextAsKeyInput(WString(arguments.code)); + } + } + } + + void GuiTextBoxCommonInterface::Install( + elements::GuiColorizedTextElement* _textElement, + compositions::GuiGraphicsComposition* _textComposition, + GuiControl* _textControl, + compositions::GuiGraphicsComposition* eventComposition, + compositions::GuiGraphicsComposition* focusableComposition + ) + { + textElement=_textElement; + textComposition=_textComposition; + textControl=_textControl; + textComposition->SetAssociatedCursor(GetCurrentController()->ResourceService()->GetSystemCursor(INativeCursor::IBeam)); + SelectionChanged.SetAssociatedComposition(eventComposition); + UndoRedoChanged.SetAssociatedComposition(eventComposition); + ModifiedChanged.SetAssociatedComposition(eventComposition); + + undoRedoProcessor->UndoRedoChanged.Add(this, &GuiTextBoxCommonInterface::InvokeUndoRedoChanged); + undoRedoProcessor->ModifiedChanged.Add(this, &GuiTextBoxCommonInterface::InvokeModifiedChanged); + + focusableComposition->GetEventReceiver()->gotFocus.AttachMethod(this, &GuiTextBoxCommonInterface::OnGotFocus); + focusableComposition->GetEventReceiver()->lostFocus.AttachMethod(this, &GuiTextBoxCommonInterface::OnLostFocus); + focusableComposition->GetEventReceiver()->caretNotify.AttachMethod(this, &GuiTextBoxCommonInterface::OnCaretNotify); + textComposition->GetEventReceiver()->leftButtonDown.AttachMethod(this, &GuiTextBoxCommonInterface::OnLeftButtonDown); + textComposition->GetEventReceiver()->leftButtonUp.AttachMethod(this, &GuiTextBoxCommonInterface::OnLeftButtonUp); + textComposition->GetEventReceiver()->mouseMove.AttachMethod(this, &GuiTextBoxCommonInterface::OnMouseMove); + focusableComposition->GetEventReceiver()->keyDown.AttachMethod(this, &GuiTextBoxCommonInterface::OnKeyDown); + focusableComposition->GetEventReceiver()->charInput.AttachMethod(this, &GuiTextBoxCommonInterface::OnCharInput); + + for(vint i=0;iAttach(textElement, elementModifyLock, textComposition ,editVersion); + } + } + + GuiTextBoxCommonInterface::ICallback* GuiTextBoxCommonInterface::GetCallback() + { + return callback; + } + + void GuiTextBoxCommonInterface::SetCallback(ICallback* value) + { + callback=value; + } + + bool GuiTextBoxCommonInterface::AttachTextEditCallback(Ptr value) + { + if(textEditCallbacks.Contains(value.Obj())) + { + return false; } else { - return GuiPopup::QueryService(identifier); - } - } - -/*********************************************************************** -GuiMenuBar -***********************************************************************/ - - IGuiMenuService* GuiMenuBar::GetParentMenuService() - { - return 0; - } - - IGuiMenuService::Direction GuiMenuBar::GetPreferredDirection() - { - return IGuiMenuService::Horizontal; - } - - bool GuiMenuBar::IsActiveState() - { - return GetOpeningMenu()!=0; - } - - bool GuiMenuBar::IsSubMenuActivatedByMouseDown() - { - return true; - } - - GuiMenuBar::GuiMenuBar(theme::ThemeName themeName) - :GuiControl(themeName) - { - } - - GuiMenuBar::~GuiMenuBar() - { - } - - IDescriptable* GuiMenuBar::QueryService(const WString& identifier) - { - if(identifier==IGuiMenuService::Identifier) - { - return (IGuiMenuService*)this; - } - else - { - return GuiControl::QueryService(identifier); - } - } - -/*********************************************************************** -GuiMenuButton -***********************************************************************/ - - void GuiMenuButton::BeforeControlTemplateUninstalled_() - { - auto host = GetSubMenuHost(); - host->Clicked.Detach(hostClickedHandler); - host->GetBoundsComposition()->GetEventReceiver()->mouseEnter.Detach(hostMouseEnterHandler); - - hostClickedHandler = nullptr; - hostMouseEnterHandler = nullptr; - } - - void GuiMenuButton::AfterControlTemplateInstalled_(bool initialize) - { - auto ct = GetControlTemplateObject(); - auto host = GetSubMenuHost(); - - ct->SetSubMenuOpening(GetSubMenuOpening()); - ct->SetImage(image); - ct->SetShortcutText(shortcutText); - ct->SetSubMenuExisting(subMenu != nullptr); - - hostClickedHandler = host->Clicked.AttachMethod(this, &GuiMenuButton::OnClicked); - hostMouseEnterHandler = host->GetBoundsComposition()->GetEventReceiver()->mouseEnter.AttachMethod(this, &GuiMenuButton::OnMouseEnter); - } - - GuiButton* GuiMenuButton::GetSubMenuHost() - { - GuiButton* button = GetControlTemplateObject()->GetSubMenuHost(); - return button ? button : this; - } - - void GuiMenuButton::OpenSubMenuInternal() - { - if(!GetSubMenuOpening()) - { - if(ownerMenuService) + textEditCallbacks.Add(value); + if(textElement) { - GuiMenu* openingSiblingMenu=ownerMenuService->GetOpeningMenu(); - if(openingSiblingMenu) - { - openingSiblingMenu->Hide(); - } + value->Attach(textElement, elementModifyLock, textComposition, editVersion); } - SetSubMenuOpening(true); + return true; } } - void GuiMenuButton::OnParentLineChanged() + bool GuiTextBoxCommonInterface::DetachTextEditCallback(Ptr value) { - GuiButton::OnParentLineChanged(); - ownerMenuService=QueryTypedService(); - if(ownerMenuService) + if(textEditCallbacks.Remove(value.Obj())) { - SetClickOnMouseUp(!ownerMenuService->IsSubMenuActivatedByMouseDown()); - } - if(subMenu) - { - subMenu->UpdateMenuService(); - } - } - - bool GuiMenuButton::IsAltAvailable() - { - return true; - } - - compositions::IGuiAltActionHost* GuiMenuButton::GetActivatingAltHost() - { - if (subMenu) - { - return subMenu->QueryTypedService(); - } - return 0; - } - - void GuiMenuButton::OnSubMenuWindowOpened(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - SubMenuOpeningChanged.Execute(GetNotifyEventArguments()); - GetControlTemplateObject()->SetSubMenuOpening(true); - } - - void GuiMenuButton::OnSubMenuWindowClosed(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - SubMenuOpeningChanged.Execute(GetNotifyEventArguments()); - GetControlTemplateObject()->SetSubMenuOpening(false); - } - - void GuiMenuButton::OnMouseEnter(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if(GetVisuallyEnabled()) - { - if(cascadeAction && ownerMenuService && ownerMenuService->IsActiveState()) - { - OpenSubMenuInternal(); - } - } - } - - void GuiMenuButton::OnClicked(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if(GetVisuallyEnabled()) - { - if(GetSubMenu()) - { - OpenSubMenuInternal(); - } - else if(ownerMenuService) - { - ownerMenuService->MenuItemExecuted(); - } - } - } - - IGuiMenuService::Direction GuiMenuButton::GetSubMenuDirection() - { - return ownerMenuService?ownerMenuService->GetPreferredDirection():IGuiMenuService::Horizontal; - } - - GuiMenuButton::GuiMenuButton(theme::ThemeName themeName) - :GuiSelectableButton(themeName) - ,subMenu(0) - ,ownedSubMenu(false) - ,ownerMenuService(0) - ,cascadeAction(true) - { - SetAutoSelection(false); - SubMenuOpeningChanged.SetAssociatedComposition(boundsComposition); - ImageChanged.SetAssociatedComposition(boundsComposition); - ShortcutTextChanged.SetAssociatedComposition(boundsComposition); - } - - GuiMenuButton::~GuiMenuButton() - { - if(subMenu && ownedSubMenu) - { - delete subMenu; - } - } - - Ptr GuiMenuButton::GetImage() - { - return image; - } - - void GuiMenuButton::SetImage(Ptr value) - { - if (image != value) - { - image = value; - GetControlTemplateObject()->SetImage(image); - ImageChanged.Execute(GetNotifyEventArguments()); - } - } - - const WString& GuiMenuButton::GetShortcutText() - { - return shortcutText; - } - - void GuiMenuButton::SetShortcutText(const WString& value) - { - if (shortcutText != value) - { - shortcutText = value; - GetControlTemplateObject()->SetShortcutText(shortcutText); - ShortcutTextChanged.Execute(GetNotifyEventArguments()); - } - } - - bool GuiMenuButton::IsSubMenuExists() - { - return subMenu!=0; - } - - GuiMenu* GuiMenuButton::GetSubMenu() - { - return subMenu; - } - - GuiMenu* GuiMenuButton::CreateSubMenu(TemplateProperty subMenuTemplate) - { - if (!subMenu) - { - GuiMenu* newSubMenu = new GuiMenu(theme::ThemeName::Menu, this); - newSubMenu->SetControlTemplate(subMenuTemplate ? subMenuTemplate : GetControlTemplateObject()->GetSubMenuTemplate()); - SetSubMenu(newSubMenu, true); - } - return subMenu; - } - - void GuiMenuButton::SetSubMenu(GuiMenu* value, bool owned) - { - if(subMenu) - { - if(ownedSubMenu) - { - delete subMenu; - } - } - subMenu=value; - ownedSubMenu=owned; - if(subMenu) - { - subMenu->WindowOpened.AttachMethod(this, &GuiMenuButton::OnSubMenuWindowOpened); - subMenu->WindowClosed.AttachMethod(this, &GuiMenuButton::OnSubMenuWindowClosed); - } - GetControlTemplateObject()->SetSubMenuExisting(subMenu != nullptr); - } - - void GuiMenuButton::DestroySubMenu() - { - if(subMenu) - { - if(ownedSubMenu) - { - delete subMenu; - } - subMenu=0; - ownedSubMenu=false; - GetControlTemplateObject()->SetSubMenuExisting(false); - } - } - - bool GuiMenuButton::GetOwnedSubMenu() - { - return subMenu && ownedSubMenu; - } - - bool GuiMenuButton::GetSubMenuOpening() - { - if(subMenu) - { - return subMenu->GetOpening(); + value->Detach(); + return true; } else { @@ -24684,48 +23927,1061 @@ GuiMenuButton } } - void GuiMenuButton::SetSubMenuOpening(bool value) + void GuiTextBoxCommonInterface::AddShortcutCommand(vint key, const Func& eventHandler) { - if(subMenu) + IGuiShortcutKeyItem* item=internalShortcutKeyManager->CreateShortcut(true, false, false, key); + item->Executed.AttachLambda([=](GuiGraphicsComposition* sender, GuiEventArgs& arguments) { - if(value) + eventHandler(); + }); + } + + elements::GuiColorizedTextElement* GuiTextBoxCommonInterface::GetTextElement() + { + return textElement; + } + + void GuiTextBoxCommonInterface::UnsafeSetText(const WString& value) + { + if(textElement) + { + TextPos end; + if(textElement->GetLines().GetCount()>0) { - subMenu->SetClientSize(preferredMenuClientSize); - IGuiMenuService::Direction direction=GetSubMenuDirection(); - subMenu->ShowPopup(GetSubMenuHost(), direction==IGuiMenuService::Horizontal); - } - else - { - subMenu->Close(); + end.row=textElement->GetLines().GetCount()-1; + end.column=textElement->GetLines().GetLine(end.row).dataLength; } + Modify(TextPos(), end, value, false); } } - Size GuiMenuButton::GetPreferredMenuClientSize() + GuiTextBoxCommonInterface::GuiTextBoxCommonInterface() + :textElement(0) + ,textComposition(0) + ,editVersion(0) + ,textControl(0) + ,callback(0) + ,dragging(false) + ,readonly(false) + ,preventEnterDueToAutoComplete(false) { - return preferredMenuClientSize; + undoRedoProcessor=new GuiTextBoxUndoRedoProcessor; + AttachTextEditCallback(undoRedoProcessor); + + internalShortcutKeyManager=new GuiShortcutKeyManager; + AddShortcutCommand('Z', Func(this, &GuiTextBoxCommonInterface::Undo)); + AddShortcutCommand('Y', Func(this, &GuiTextBoxCommonInterface::Redo)); + AddShortcutCommand('A', Func(this, &GuiTextBoxCommonInterface::SelectAll)); + AddShortcutCommand('X', Func(this, &GuiTextBoxCommonInterface::Cut)); + AddShortcutCommand('C', Func(this, &GuiTextBoxCommonInterface::Copy)); + AddShortcutCommand('V', Func(this, &GuiTextBoxCommonInterface::Paste)); } - void GuiMenuButton::SetPreferredMenuClientSize(Size value) + GuiTextBoxCommonInterface::~GuiTextBoxCommonInterface() { - preferredMenuClientSize=value; + if(colorizer) + { + DetachTextEditCallback(colorizer); + colorizer=0; + } + if(undoRedoProcessor) + { + DetachTextEditCallback(undoRedoProcessor); + undoRedoProcessor=0; + } + + for(vint i=0;iDetach(); + } + textEditCallbacks.Clear(); } - bool GuiMenuButton::GetCascadeAction() + //================ clipboard operations + + bool GuiTextBoxCommonInterface::CanCut() { - return cascadeAction; + return !readonly && textElement->GetCaretBegin()!=textElement->GetCaretEnd() && textElement->GetPasswordChar()==L'\0'; } - void GuiMenuButton::SetCascadeAction(bool value) + bool GuiTextBoxCommonInterface::CanCopy() { - cascadeAction=value; + return textElement->GetCaretBegin()!=textElement->GetCaretEnd() && textElement->GetPasswordChar()==L'\0'; + } + + bool GuiTextBoxCommonInterface::CanPaste() + { + return !readonly && GetCurrentController()->ClipboardService()->ContainsText() && textElement->GetPasswordChar()==L'\0'; + } + + bool GuiTextBoxCommonInterface::Cut() + { + if(CanCut()) + { + GetCurrentController()->ClipboardService()->SetText(GetSelectionText()); + SetSelectionText(L""); + return true; + } + else + { + return false; + } + } + + bool GuiTextBoxCommonInterface::Copy() + { + if(CanCopy()) + { + GetCurrentController()->ClipboardService()->SetText(GetSelectionText()); + return true; + } + else + { + return false; + } + } + + bool GuiTextBoxCommonInterface::Paste() + { + if(CanPaste()) + { + SetSelectionText(GetCurrentController()->ClipboardService()->GetText()); + return true; + } + else + { + return false; + } + } + + //================ editing control + + bool GuiTextBoxCommonInterface::GetReadonly() + { + return readonly; + } + + void GuiTextBoxCommonInterface::SetReadonly(bool value) + { + readonly=value; + } + + //================ text operations + + void GuiTextBoxCommonInterface::Select(TextPos begin, TextPos end) + { + Move(begin, false); + Move(end, true); + } + + void GuiTextBoxCommonInterface::SelectAll() + { + vint row=textElement->GetLines().GetCount()-1; + Move(TextPos(0, 0), false); + Move(TextPos(row, textElement->GetLines().GetLine(row).dataLength), true); + } + + WString GuiTextBoxCommonInterface::GetSelectionText() + { + TextPos selectionBegin=textElement->GetCaretBegin()GetCaretEnd()?textElement->GetCaretBegin():textElement->GetCaretEnd(); + TextPos selectionEnd=textElement->GetCaretBegin()>textElement->GetCaretEnd()?textElement->GetCaretBegin():textElement->GetCaretEnd(); + return textElement->GetLines().GetText(selectionBegin, selectionEnd); + } + + void GuiTextBoxCommonInterface::SetSelectionText(const WString& value) + { + Modify(textElement->GetCaretBegin(), textElement->GetCaretEnd(), value, false); + } + + void GuiTextBoxCommonInterface::SetSelectionTextAsKeyInput(const WString& value) + { + Modify(textElement->GetCaretBegin(), textElement->GetCaretEnd(), value, true); + } + + WString GuiTextBoxCommonInterface::GetRowText(vint row) + { + TextPos start=textElement->GetLines().Normalize(TextPos(row, 0)); + TextPos end=TextPos(start.row, textElement->GetLines().GetLine(start.row).dataLength); + return GetFragmentText(start, end); + } + + vint GuiTextBoxCommonInterface::GetRowCount() + { + return textElement->GetLines().GetCount(); + } + + WString GuiTextBoxCommonInterface::GetFragmentText(TextPos start, TextPos end) + { + start=textElement->GetLines().Normalize(start); + end=textElement->GetLines().Normalize(end); + return textElement->GetLines().GetText(start, end); + } + + TextPos GuiTextBoxCommonInterface::GetCaretBegin() + { + return textElement->GetCaretBegin(); + } + + TextPos GuiTextBoxCommonInterface::GetCaretEnd() + { + return textElement->GetCaretEnd(); + } + + TextPos GuiTextBoxCommonInterface::GetCaretSmall() + { + TextPos c1=GetCaretBegin(); + TextPos c2=GetCaretEnd(); + return c1c2?c1:c2; + } + + //================ position query + + vint GuiTextBoxCommonInterface::GetRowWidth(vint row) + { + return textElement->GetLines().GetRowWidth(row); + } + + vint GuiTextBoxCommonInterface::GetRowHeight() + { + return textElement->GetLines().GetRowHeight(); + } + + vint GuiTextBoxCommonInterface::GetMaxWidth() + { + return textElement->GetLines().GetMaxWidth(); + } + + vint GuiTextBoxCommonInterface::GetMaxHeight() + { + return textElement->GetLines().GetMaxHeight(); + } + + TextPos GuiTextBoxCommonInterface::GetTextPosFromPoint(Point point) + { + Point view=textElement->GetViewPosition(); + return textElement->GetLines().GetTextPosFromPoint(Point(point.x+view.x, point.y+view.y)); + } + + Point GuiTextBoxCommonInterface::GetPointFromTextPos(TextPos pos) + { + Point view=textElement->GetViewPosition(); + Point result=textElement->GetLines().GetPointFromTextPos(pos); + return Point(result.x-view.x, result.y-view.y); + } + + Rect GuiTextBoxCommonInterface::GetRectFromTextPos(TextPos pos) + { + Point view=textElement->GetViewPosition(); + Rect result=textElement->GetLines().GetRectFromTextPos(pos); + return Rect(Point(result.x1-view.x, result.y1-view.y), result.GetSize()); + } + + TextPos GuiTextBoxCommonInterface::GetNearestTextPos(Point point) + { + Point viewPosition=textElement->GetViewPosition(); + Point mousePosition=Point(point.x+viewPosition.x, point.y+viewPosition.y); + TextPos pos=textElement->GetLines().GetTextPosFromPoint(mousePosition); + if(pos.columnGetLines().GetLine(pos.row).dataLength) + { + Rect rect=textElement->GetLines().GetRectFromTextPos(pos); + if(abs((int)(rect.x1-mousePosition.x))>=abs((int)(rect.x2-1-mousePosition.x))) + { + pos.column++; + } + } + return pos; + } + + //================ colorizing + + Ptr GuiTextBoxCommonInterface::GetColorizer() + { + return colorizer; + } + + void GuiTextBoxCommonInterface::SetColorizer(Ptr value) + { + if (!filledDefaultColors) + { + filledDefaultColors = true; + CopyFrom(defaultColors, GetTextElement()->GetColors()); + } + + if(colorizer) + { + DetachTextEditCallback(colorizer); + } + colorizer=value; + if(colorizer) + { + AttachTextEditCallback(colorizer); + GetTextElement()->SetColors(colorizer->GetColors()); + } + else + { + GetTextElement()->SetColors(defaultColors); + GetTextElement()->ResetTextColorIndex(0); + } + } + + //================ auto complete + + Ptr GuiTextBoxCommonInterface::GetAutoComplete() + { + return autoComplete; + } + + void GuiTextBoxCommonInterface::SetAutoComplete(Ptr value) + { + if(autoComplete) + { + DetachTextEditCallback(autoComplete); + } + autoComplete=value; + if(autoComplete) + { + AttachTextEditCallback(autoComplete); + } + } + + //================ undo redo control + + vuint GuiTextBoxCommonInterface::GetEditVersion() + { + return editVersion; + } + + bool GuiTextBoxCommonInterface::CanUndo() + { + return !readonly && undoRedoProcessor->CanUndo(); + } + + bool GuiTextBoxCommonInterface::CanRedo() + { + return !readonly && undoRedoProcessor->CanRedo(); + } + + void GuiTextBoxCommonInterface::ClearUndoRedo() + { + undoRedoProcessor->ClearUndoRedo(); + } + + bool GuiTextBoxCommonInterface::GetModified() + { + return undoRedoProcessor->GetModified(); + } + + void GuiTextBoxCommonInterface::NotifyModificationSaved() + { + undoRedoProcessor->NotifyModificationSaved(); + } + + bool GuiTextBoxCommonInterface::Undo() + { + if(CanUndo()) + { + return undoRedoProcessor->Undo(); + } + else + { + return false; + } + } + + bool GuiTextBoxCommonInterface::Redo() + { + if(CanRedo()) + { + return undoRedoProcessor->Redo(); + } + else + { + return false; + } } } } } /*********************************************************************** -.\CONTROLS\TOOLSTRIPPACKAGE\GUITOOLSTRIPMENU.CPP +.\CONTROLS\TEXTEDITORPACKAGE\GUITEXTCONTROLS.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace controls + { + using namespace elements; + using namespace elements::text; + using namespace compositions; + using namespace collections; + +/*********************************************************************** +GuiMultilineTextBox::DefaultTextElementOperatorCallback +***********************************************************************/ + + GuiMultilineTextBox::TextElementOperatorCallback::TextElementOperatorCallback(GuiMultilineTextBox* _textControl) + :GuiTextBoxCommonInterface::DefaultCallback( + _textControl->textElement, + _textControl->textComposition + ) + ,textControl(_textControl) + { + } + + void GuiMultilineTextBox::TextElementOperatorCallback::AfterModify(TextPos originalStart, TextPos originalEnd, const WString& originalText, TextPos inputStart, TextPos inputEnd, const WString& inputText) + { + textControl->CalculateView(); + } + + void GuiMultilineTextBox::TextElementOperatorCallback::ScrollToView(Point point) + { + point.x+=TextMargin; + point.y+=TextMargin; + Point oldPoint(textControl->GetHorizontalScroll()->GetPosition(), textControl->GetVerticalScroll()->GetPosition()); + vint marginX=0; + vint marginY=0; + if(oldPoint.xpoint.x) + { + marginX=-TextMargin; + } + if(oldPoint.ypoint.y) + { + marginY=-TextMargin; + } + textControl->GetHorizontalScroll()->SetPosition(point.x+marginX); + textControl->GetVerticalScroll()->SetPosition(point.y+marginY); + } + + vint GuiMultilineTextBox::TextElementOperatorCallback::GetTextMargin() + { + return TextMargin; + } + +/*********************************************************************** +GuiMultilineTextBox::CommandExecutor +***********************************************************************/ + + GuiMultilineTextBox::CommandExecutor::CommandExecutor(GuiMultilineTextBox* _textBox) + :textBox(_textBox) + { + } + + GuiMultilineTextBox::CommandExecutor::~CommandExecutor() + { + } + + void GuiMultilineTextBox::CommandExecutor::UnsafeSetText(const WString& value) + { + textBox->UnsafeSetText(value); + } + +/*********************************************************************** +GuiMultilineTextBox +***********************************************************************/ + + void GuiMultilineTextBox::BeforeControlTemplateUninstalled_() + { + auto ct = GetControlTemplateObject(); + ct->SetCommands(nullptr); + } + + void GuiMultilineTextBox::AfterControlTemplateInstalled_(bool initialize) + { + auto ct = GetControlTemplateObject(); + Array colors(1); + colors[0] = ct->GetTextColor(); + textElement->SetColors(colors); + textElement->SetCaretColor(ct->GetCaretColor()); + ct->SetCommands(commandExecutor.Obj()); + } + + void GuiMultilineTextBox::CalculateViewAndSetScroll() + { + auto ct = GetControlTemplateObject(); + CalculateView(); + vint smallMove = textElement->GetLines().GetRowHeight(); + vint bigMove = smallMove * 5; + ct->GetHorizontalScroll()->SetSmallMove(smallMove); + ct->GetHorizontalScroll()->SetBigMove(bigMove); + ct->GetVerticalScroll()->SetSmallMove(smallMove); + ct->GetVerticalScroll()->SetBigMove(bigMove); + } + + void GuiMultilineTextBox::OnVisuallyEnabledChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + textElement->SetVisuallyEnabled(GetVisuallyEnabled()); + } + + Size GuiMultilineTextBox::QueryFullSize() + { + text::TextLines& lines = textElement->GetLines(); + return Size(lines.GetMaxWidth() + TextMargin * 2, lines.GetMaxHeight() + TextMargin * 2); + } + + void GuiMultilineTextBox::UpdateView(Rect viewBounds) + { + textElement->SetViewPosition(viewBounds.LeftTop() - Size(TextMargin, TextMargin)); + } + + void GuiMultilineTextBox::OnRenderTargetChanged(elements::IGuiGraphicsRenderTarget* renderTarget) + { + CalculateViewAndSetScroll(); + GuiScrollView::OnRenderTargetChanged(renderTarget); + } + + void GuiMultilineTextBox::OnBoundsMouseButtonDown(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) + { + if(GetVisuallyEnabled()) + { + boundsComposition->GetRelatedGraphicsHost()->SetFocus(boundsComposition); + } + } + + GuiMultilineTextBox::GuiMultilineTextBox(theme::ThemeName themeName) + :GuiScrollView(themeName) + { + textElement = GuiColorizedTextElement::Create(); + textElement->SetFont(GetFont()); + + textComposition = new GuiBoundsComposition; + textComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + textComposition->SetOwnedElement(textElement); + containerComposition->AddChild(textComposition); + + callback = new TextElementOperatorCallback(this); + commandExecutor = new CommandExecutor(this); + + SetFocusableComposition(boundsComposition); + Install(textElement, textComposition, this, boundsComposition, focusableComposition); + SetCallback(callback.Obj()); + + VisuallyEnabledChanged.AttachMethod(this, &GuiMultilineTextBox::OnVisuallyEnabledChanged); + boundsComposition->GetEventReceiver()->leftButtonDown.AttachMethod(this, &GuiMultilineTextBox::OnBoundsMouseButtonDown); + boundsComposition->GetEventReceiver()->middleButtonDown.AttachMethod(this, &GuiMultilineTextBox::OnBoundsMouseButtonDown); + boundsComposition->GetEventReceiver()->rightButtonDown.AttachMethod(this, &GuiMultilineTextBox::OnBoundsMouseButtonDown); + } + + GuiMultilineTextBox::~GuiMultilineTextBox() + { + } + + const WString& GuiMultilineTextBox::GetText() + { + text = textElement->GetLines().GetText(); + return text; + } + + void GuiMultilineTextBox::SetText(const WString& value) + { + UnsafeSetText(value); + textElement->SetCaretBegin(TextPos(0, 0)); + textElement->SetCaretEnd(TextPos(0, 0)); + CalculateView(); + } + + void GuiMultilineTextBox::SetFont(const FontProperties& value) + { + GuiControl::SetFont(value); + textElement->SetFont(value); + CalculateViewAndSetScroll(); + } + +/*********************************************************************** +GuiSinglelineTextBox::DefaultTextElementOperatorCallback +***********************************************************************/ + + GuiSinglelineTextBox::TextElementOperatorCallback::TextElementOperatorCallback(GuiSinglelineTextBox* _textControl) + :GuiTextBoxCommonInterface::DefaultCallback( + _textControl->textElement, + _textControl->textComposition + ) + { + } + + bool GuiSinglelineTextBox::TextElementOperatorCallback::BeforeModify(TextPos start, TextPos end, const WString& originalText, WString& inputText) + { + vint length=inputText.Length(); + const wchar_t* input=inputText.Buffer(); + for(vint i=0;iGetViewPosition().x; + vint marginX=0; + if(oldXnewX) + { + marginX=-TextMargin; + } + + newX+=marginX; + vint minX=-TextMargin; + vint maxX=textElement->GetLines().GetMaxWidth()+TextMargin-textComposition->GetBounds().Width(); + if(newX>=maxX) + { + newX=maxX-1; + } + if(newXSetViewPosition(Point(newX, -TextMargin)); + } + + vint GuiSinglelineTextBox::TextElementOperatorCallback::GetTextMargin() + { + return TextMargin; + } + +/*********************************************************************** +GuiSinglelineTextBox +***********************************************************************/ + + void GuiSinglelineTextBox::BeforeControlTemplateUninstalled_() + { + } + + void GuiSinglelineTextBox::AfterControlTemplateInstalled_(bool initialize) + { + auto ct = GetControlTemplateObject(); + Array colors(1); + colors[0] = ct->GetTextColor(); + textElement->SetColors(colors); + textElement->SetCaretColor(ct->GetCaretColor()); + } + + void GuiSinglelineTextBox::RearrangeTextElement() + { + textCompositionTable->SetRowOption( + 1, + GuiCellOption::AbsoluteOption( + textElement->GetLines().GetRowHeight() + 2 * TextMargin) + ); + } + + void GuiSinglelineTextBox::OnRenderTargetChanged(elements::IGuiGraphicsRenderTarget* renderTarget) + { + GuiControl::OnRenderTargetChanged(renderTarget); + RearrangeTextElement(); + } + + void GuiSinglelineTextBox::OnVisuallyEnabledChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + textElement->SetVisuallyEnabled(GetVisuallyEnabled()); + } + + void GuiSinglelineTextBox::OnBoundsMouseButtonDown(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) + { + if(GetVisuallyEnabled()) + { + boundsComposition->GetRelatedGraphicsHost()->SetFocus(boundsComposition); + } + } + + GuiSinglelineTextBox::GuiSinglelineTextBox(theme::ThemeName themeName) + :GuiControl(themeName) + { + textElement = GuiColorizedTextElement::Create(); + textElement->SetFont(GetFont()); + textElement->SetViewPosition(Point(-GuiSinglelineTextBox::TextMargin, -GuiSinglelineTextBox::TextMargin)); + + textCompositionTable = new GuiTableComposition; + textCompositionTable->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + textCompositionTable->SetAlignmentToParent(Margin(0, 0, 0, 0)); + textCompositionTable->SetRowsAndColumns(3, 1); + textCompositionTable->SetRowOption(0, GuiCellOption::PercentageOption(0.5)); + textCompositionTable->SetRowOption(1, GuiCellOption::AbsoluteOption(0)); + textCompositionTable->SetRowOption(2, GuiCellOption::PercentageOption(0.5)); + textCompositionTable->SetColumnOption(0, GuiCellOption::PercentageOption(1.0)); + containerComposition->AddChild(textCompositionTable); + + textComposition = new GuiCellComposition; + textComposition->SetOwnedElement(textElement); + textCompositionTable->AddChild(textComposition); + textComposition->SetSite(1, 0, 1, 1); + + callback = new TextElementOperatorCallback(this); + SetFocusableComposition(boundsComposition); + Install(textElement, textComposition, this, boundsComposition, focusableComposition); + SetCallback(callback.Obj()); + + VisuallyEnabledChanged.AttachMethod(this, &GuiSinglelineTextBox::OnVisuallyEnabledChanged); + boundsComposition->GetEventReceiver()->leftButtonDown.AttachMethod(this, &GuiSinglelineTextBox::OnBoundsMouseButtonDown); + boundsComposition->GetEventReceiver()->middleButtonDown.AttachMethod(this, &GuiSinglelineTextBox::OnBoundsMouseButtonDown); + boundsComposition->GetEventReceiver()->rightButtonDown.AttachMethod(this, &GuiSinglelineTextBox::OnBoundsMouseButtonDown); + } + + GuiSinglelineTextBox::~GuiSinglelineTextBox() + { + } + + const WString& GuiSinglelineTextBox::GetText() + { + text = textElement->GetLines().GetText(); + return text; + } + + void GuiSinglelineTextBox::SetText(const WString& value) + { + UnsafeSetText(value); + textElement->SetCaretBegin(TextPos(0, 0)); + textElement->SetCaretEnd(TextPos(0, 0)); + } + + void GuiSinglelineTextBox::SetFont(const FontProperties& value) + { + GuiControl::SetFont(value); + textElement->SetFont(value); + RearrangeTextElement(); + } + + wchar_t GuiSinglelineTextBox::GetPasswordChar() + { + return textElement->GetPasswordChar(); + } + + void GuiSinglelineTextBox::SetPasswordChar(wchar_t value) + { + textElement->SetPasswordChar(value); + } + } + } +} + +/*********************************************************************** +.\CONTROLS\TEXTEDITORPACKAGE\EDITORCALLBACK\GUITEXTUNDOREDO.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace controls + { + using namespace elements; + using namespace elements::text; + using namespace compositions; + +/*********************************************************************** +GuiGeneralUndoRedoProcessor +***********************************************************************/ + + GuiGeneralUndoRedoProcessor::GuiGeneralUndoRedoProcessor() + :firstFutureStep(0) + ,savedStep(0) + ,performingUndoRedo(false) + { + } + + GuiGeneralUndoRedoProcessor::~GuiGeneralUndoRedoProcessor() + { + } + + void GuiGeneralUndoRedoProcessor::PushStep(Ptr step) + { + if(!performingUndoRedo) + { + if(firstFutureStep0) + { + steps.RemoveRange(firstFutureStep, count); + } + + steps.Add(step); + firstFutureStep=steps.Count(); + UndoRedoChanged(); + ModifiedChanged(); + } + } + + bool GuiGeneralUndoRedoProcessor::CanUndo() + { + return firstFutureStep>0; + } + + bool GuiGeneralUndoRedoProcessor::CanRedo() + { + return steps.Count()>firstFutureStep; + } + + void GuiGeneralUndoRedoProcessor::ClearUndoRedo() + { + if(!performingUndoRedo) + { + steps.Clear(); + firstFutureStep=0; + savedStep=-1; + } + } + + bool GuiGeneralUndoRedoProcessor::GetModified() + { + return firstFutureStep!=savedStep; + } + + void GuiGeneralUndoRedoProcessor::NotifyModificationSaved() + { + if(!performingUndoRedo) + { + savedStep=firstFutureStep; + ModifiedChanged(); + } + } + + bool GuiGeneralUndoRedoProcessor::Undo() + { + if(!CanUndo()) return false; + performingUndoRedo=true; + firstFutureStep--; + steps[firstFutureStep]->Undo(); + performingUndoRedo=false; + UndoRedoChanged(); + ModifiedChanged(); + return true; + } + + bool GuiGeneralUndoRedoProcessor::Redo() + { + if(!CanRedo()) return false; + performingUndoRedo=true; + firstFutureStep++; + steps[firstFutureStep-1]->Redo(); + performingUndoRedo=false; + UndoRedoChanged(); + ModifiedChanged(); + return true; + } + +/*********************************************************************** +GuiTextBoxUndoRedoProcessor::EditStep +***********************************************************************/ + + void GuiTextBoxUndoRedoProcessor::EditStep::Undo() + { + GuiTextBoxCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); + if(ci) + { + ci->Select(arguments.inputStart, arguments.inputEnd); + ci->SetSelectionText(arguments.originalText); + ci->Select(arguments.originalStart, arguments.originalEnd); + } + } + + void GuiTextBoxUndoRedoProcessor::EditStep::Redo() + { + GuiTextBoxCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); + if(ci) + { + ci->Select(arguments.originalStart, arguments.originalEnd); + ci->SetSelectionText(arguments.inputText); + ci->Select(arguments.inputStart, arguments.inputEnd); + } + } + +/*********************************************************************** +GuiTextBoxUndoRedoProcessor +***********************************************************************/ + + GuiTextBoxUndoRedoProcessor::GuiTextBoxUndoRedoProcessor() + :ownerComposition(0) + { + } + + GuiTextBoxUndoRedoProcessor::~GuiTextBoxUndoRedoProcessor() + { + } + + void GuiTextBoxUndoRedoProcessor::Attach(elements::GuiColorizedTextElement* element, SpinLock& elementModifyLock, compositions::GuiGraphicsComposition* _ownerComposition, vuint editVersion) + { + ownerComposition=_ownerComposition; + } + + void GuiTextBoxUndoRedoProcessor::Detach() + { + ClearUndoRedo(); + } + + void GuiTextBoxUndoRedoProcessor::TextEditPreview(TextEditPreviewStruct& arguments) + { + } + + void GuiTextBoxUndoRedoProcessor::TextEditNotify(const TextEditNotifyStruct& arguments) + { + Ptr step=new EditStep; + step->processor=this; + step->arguments=arguments; + PushStep(step); + } + + void GuiTextBoxUndoRedoProcessor::TextCaretChanged(const TextCaretChangedStruct& arguments) + { + } + + void GuiTextBoxUndoRedoProcessor::TextEditFinished(vuint editVersion) + { + } + +/*********************************************************************** +GuiDocumentUndoRedoProcessor::ReplaceModelStep +***********************************************************************/ + + void GuiDocumentUndoRedoProcessor::ReplaceModelStep::Undo() + { + GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); + if(ci) + { + ci->EditRun(arguments.inputStart, arguments.inputEnd, arguments.originalModel, true); + ci->SetCaret(arguments.originalStart, arguments.originalEnd); + } + } + + void GuiDocumentUndoRedoProcessor::ReplaceModelStep::Redo() + { + GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); + if(ci) + { + ci->EditRun(arguments.originalStart, arguments.originalEnd, arguments.inputModel, true); + ci->SetCaret(arguments.inputStart, arguments.inputEnd); + } + } + +/*********************************************************************** +GuiDocumentUndoRedoProcessor::RenameStyleStep +***********************************************************************/ + + void GuiDocumentUndoRedoProcessor::RenameStyleStep::Undo() + { + GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); + if(ci) + { + ci->RenameStyle(arguments.newStyleName, arguments.oldStyleName); + } + } + + void GuiDocumentUndoRedoProcessor::RenameStyleStep::Redo() + { + GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); + if(ci) + { + ci->RenameStyle(arguments.oldStyleName, arguments.newStyleName); + } + } + +/*********************************************************************** +GuiDocumentUndoRedoProcessor::SetAlignmentStep +***********************************************************************/ + + void GuiDocumentUndoRedoProcessor::SetAlignmentStep::Undo() + { + GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); + if(ci) + { + ci->SetParagraphAlignments(TextPos(arguments->start, 0), TextPos(arguments->end, 0), arguments->originalAlignments); + } + } + + void GuiDocumentUndoRedoProcessor::SetAlignmentStep::Redo() + { + GuiDocumentCommonInterface* ci=dynamic_cast(processor->ownerComposition->GetRelatedControl()); + if(ci) + { + ci->SetParagraphAlignments(TextPos(arguments->start, 0), TextPos(arguments->end, 0), arguments->inputAlignments); + } + } + +/*********************************************************************** +GuiDocumentUndoRedoProcessor +***********************************************************************/ + + GuiDocumentUndoRedoProcessor::GuiDocumentUndoRedoProcessor() + :element(0) + ,ownerComposition(0) + { + } + + GuiDocumentUndoRedoProcessor::~GuiDocumentUndoRedoProcessor() + { + } + + void GuiDocumentUndoRedoProcessor::Setup(elements::GuiDocumentElement* _element, compositions::GuiGraphicsComposition* _ownerComposition) + { + element=_element; + ownerComposition=_ownerComposition; + } + + void GuiDocumentUndoRedoProcessor::OnReplaceModel(const ReplaceModelStruct& arguments) + { + Ptr step=new ReplaceModelStep; + step->processor=this; + step->arguments=arguments; + PushStep(step); + } + + void GuiDocumentUndoRedoProcessor::OnRenameStyle(const RenameStyleStruct& arguments) + { + Ptr step=new RenameStyleStep; + step->processor=this; + step->arguments=arguments; + PushStep(step); + } + + void GuiDocumentUndoRedoProcessor::OnSetAlignment(Ptr arguments) + { + Ptr step=new SetAlignmentStep; + step->processor=this; + step->arguments=arguments; + PushStep(step); + } + } + } +} + +/*********************************************************************** +.\CONTROLS\TEXTEDITORPACKAGE\GUIDOCUMENTVIEWER.CPP ***********************************************************************/ namespace vl @@ -24735,1223 +24991,534 @@ namespace vl namespace controls { using namespace collections; + using namespace elements; using namespace compositions; /*********************************************************************** -GuiToolstripCollection +GuiDocumentItem ***********************************************************************/ - void GuiToolstripCollection::InvokeUpdateLayout() + GuiDocumentItem::GuiDocumentItem(const WString& _name) + :name(_name) { - if(contentCallback) + container = new GuiBoundsComposition; + container->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + container->SetAssociatedCursor(GetCurrentController()->ResourceService()->GetSystemCursor(INativeCursor::Arrow)); + } + + GuiDocumentItem::~GuiDocumentItem() + { + if (!owned) { - contentCallback->UpdateLayout(); + SafeDeleteComposition(container); } } - void GuiToolstripCollection::OnInterestingMenuButtonPropertyChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + compositions::GuiGraphicsComposition* GuiDocumentItem::GetContainer() { - InvokeUpdateLayout(); + return container; } - bool GuiToolstripCollection::QueryInsert(vint index, GuiControl* const& child) - { - return true; - } - - bool GuiToolstripCollection::QueryRemove(vint index, GuiControl* const& child) - { - return true; - } - - void GuiToolstripCollection::BeforeInsert(vint index, GuiControl* const& child) - { - } - - void GuiToolstripCollection::BeforeRemove(vint index, GuiControl* const& child) - { - GuiStackItemComposition* stackItem = stackComposition->GetStackItems().Get(index); - stackComposition->RemoveChild(stackItem); - stackItem->RemoveChild(child->GetBoundsComposition()); - delete stackItem; - delete child; - InvokeUpdateLayout(); - } - - void GuiToolstripCollection::AfterInsert(vint index, GuiControl* const& child) - { - GuiStackItemComposition* stackItem=new GuiStackItemComposition; - child->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); - stackItem->AddChild(child->GetBoundsComposition()); - stackComposition->InsertChild(index, stackItem); - - GuiMenuButton* menuButton=dynamic_cast(child); - if(menuButton) - { - menuButton->TextChanged.AttachMethod(this, &GuiToolstripCollection::OnInterestingMenuButtonPropertyChanged); - menuButton->ShortcutTextChanged.AttachMethod(this, &GuiToolstripCollection::OnInterestingMenuButtonPropertyChanged); - } - InvokeUpdateLayout(); - } - - void GuiToolstripCollection::AfterRemove(vint index, vint count) - { - InvokeUpdateLayout(); - } - - GuiToolstripCollection::GuiToolstripCollection(IContentCallback* _contentCallback, compositions::GuiStackComposition* _stackComposition) - :contentCallback(_contentCallback) - ,stackComposition(_stackComposition) - { - } - - GuiToolstripCollection::~GuiToolstripCollection() + WString GuiDocumentItem::GetName() { + return name; } /*********************************************************************** -GuiToolstripMenu -***********************************************************************/ - - void GuiToolstripMenu::UpdateLayout() - { - sharedSizeRootComposition->ForceCalculateSizeImmediately(); - } - - GuiToolstripMenu::GuiToolstripMenu(theme::ThemeName themeName, GuiControl* _owner) - :GuiMenu(themeName, _owner) - { - sharedSizeRootComposition = new GuiSharedSizeRootComposition(); - sharedSizeRootComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); - sharedSizeRootComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - containerComposition->AddChild(sharedSizeRootComposition); - - stackComposition=new GuiStackComposition; - stackComposition->SetDirection(GuiStackComposition::Vertical); - stackComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); - stackComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - sharedSizeRootComposition->AddChild(stackComposition); - - toolstripItems = new GuiToolstripCollection(this, stackComposition); - } - - GuiToolstripMenu::~GuiToolstripMenu() - { - } - - GuiToolstripCollection& GuiToolstripMenu::GetToolstripItems() - { - return *toolstripItems.Obj(); - } - -/*********************************************************************** -GuiToolstripMenuBar +GuiDocumentCommonInterface ***********************************************************************/ - GuiToolstripMenuBar::GuiToolstripMenuBar(theme::ThemeName themeName) - :GuiMenuBar(themeName) + void GuiDocumentCommonInterface::InvokeUndoRedoChanged() { - stackComposition=new GuiStackComposition; - stackComposition->SetDirection(GuiStackComposition::Horizontal); - stackComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); - stackComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - containerComposition->AddChild(stackComposition); - - toolstripItems=new GuiToolstripCollection(0, stackComposition); + UndoRedoChanged.Execute(documentControl->GetNotifyEventArguments()); } - GuiToolstripMenuBar::~GuiToolstripMenuBar() + void GuiDocumentCommonInterface::InvokeModifiedChanged() { + ModifiedChanged.Execute(documentControl->GetNotifyEventArguments()); } - GuiToolstripCollection& GuiToolstripMenuBar::GetToolstripItems() + void GuiDocumentCommonInterface::UpdateCaretPoint() { - return *toolstripItems.Obj(); + GuiGraphicsHost* host=documentComposition->GetRelatedGraphicsHost(); + if(host) + { + Rect caret=documentElement->GetCaretBounds(documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide()); + Point view=GetDocumentViewPosition(); + vint x=caret.x1-view.x; + vint y=caret.y2-view.y; + host->SetCaretPoint(Point(x, y), documentComposition); + } } -/*********************************************************************** -GuiToolstripToolBar -***********************************************************************/ + void GuiDocumentCommonInterface::Move(TextPos caret, bool shift, bool frontSide) + { + TextPos begin=documentElement->GetCaretBegin(); + TextPos end=documentElement->GetCaretEnd(); - GuiToolstripToolBar::GuiToolstripToolBar(theme::ThemeName themeName) - :GuiControl(themeName) - { - stackComposition=new GuiStackComposition; - stackComposition->SetDirection(GuiStackComposition::Horizontal); - stackComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); - stackComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - containerComposition->AddChild(stackComposition); + TextPos newBegin=shift?begin:caret; + TextPos newEnd=caret; + documentElement->SetCaret(newBegin, newEnd, frontSide); + documentElement->SetCaretVisible(true); - toolstripItems=new GuiToolstripCollection(0, stackComposition); - } - - GuiToolstripToolBar::~GuiToolstripToolBar() - { - } - - GuiToolstripCollection& GuiToolstripToolBar::GetToolstripItems() - { - return *toolstripItems.Obj(); - } - -/*********************************************************************** -GuiToolstripButton -***********************************************************************/ - - void GuiToolstripButton::UpdateCommandContent() - { - if(command) + Rect bounds=documentElement->GetCaretBounds(newEnd, frontSide); + if(bounds!=Rect()) { - SetImage(command->GetImage()); - SetText(command->GetText()); - SetEnabled(command->GetEnabled()); - SetSelected(command->GetSelected()); - if(command->GetShortcut()) - { - SetShortcutText(command->GetShortcut()->GetName()); - } - else - { - SetShortcutText(L""); - } + bounds.x1-=15; + bounds.y1-=15; + bounds.x2+=15; + bounds.y2+=15; + EnsureRectVisible(bounds); } - else + UpdateCaretPoint(); + SelectionChanged.Execute(documentControl->GetNotifyEventArguments()); + } + + bool GuiDocumentCommonInterface::ProcessKey(vint code, bool shift, bool ctrl) + { + if(IGuiShortcutKeyItem* item=internalShortcutKeyManager->TryGetShortcut(ctrl, shift, false, code)) { - SetImage(0); - SetText(L""); - SetEnabled(true); - SetSelected(false); - SetShortcutText(L""); - } - } - - void GuiToolstripButton::OnClicked(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - if(command) - { - command->Executed.ExecuteWithNewSender(arguments, sender); - } - } - - void GuiToolstripButton::OnCommandDescriptionChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) - { - UpdateCommandContent(); - } - - GuiToolstripButton::GuiToolstripButton(theme::ThemeName themeName) - :GuiMenuButton(themeName) - ,command(0) - { - Clicked.AttachMethod(this, &GuiToolstripButton::OnClicked); - } - - GuiToolstripButton::~GuiToolstripButton() - { - } - - GuiToolstripCommand* GuiToolstripButton::GetCommand() - { - return command; - } - - void GuiToolstripButton::SetCommand(GuiToolstripCommand* value) - { - if(command!=value) - { - if(command) - { - command->DescriptionChanged.Detach(descriptionChangedHandler); - } - command=0; - descriptionChangedHandler=0; - if(value) - { - command=value; - descriptionChangedHandler=command->DescriptionChanged.AttachMethod(this, &GuiToolstripButton::OnCommandDescriptionChanged); - } - UpdateCommandContent(); - } - } - - GuiToolstripMenu* GuiToolstripButton::GetToolstripSubMenu() - { - return dynamic_cast(GetSubMenu()); - } - - GuiToolstripMenu* GuiToolstripButton::EnsureToolstripSubMenu() - { - if (!GetSubMenu()) - { - CreateToolstripSubMenu({}); - } - return dynamic_cast(GetSubMenu()); - } - - void GuiToolstripButton::CreateToolstripSubMenu(TemplateProperty subMenuTemplate) - { - if (!subMenu) - { - auto newSubMenu = new GuiToolstripMenu(theme::ThemeName::Menu, this); - if (subMenuTemplate) - { - newSubMenu->SetControlTemplate(subMenuTemplate); - } - else - { - newSubMenu->SetControlTemplate(GetControlTemplateObject()->GetSubMenuTemplate()); - } - SetSubMenu(newSubMenu, true); - } - } - } - } -} - -/*********************************************************************** -.\GRAPHICSELEMENT\GUIGRAPHICSHOST.CPP -***********************************************************************/ - -namespace vl -{ - namespace presentation - { - namespace compositions - { - using namespace collections; - using namespace controls; - using namespace elements; - using namespace theme; - -/*********************************************************************** -GuiGraphicsAnimationManager -***********************************************************************/ - - GuiGraphicsAnimationManager::GuiGraphicsAnimationManager() - { - } - - GuiGraphicsAnimationManager::~GuiGraphicsAnimationManager() - { - } - - void GuiGraphicsAnimationManager::AddAnimation(Ptr animation) - { - playingAnimations.Add(animation); - } - - bool GuiGraphicsAnimationManager::HasAnimation() - { - return playingAnimations.Count()>0; - } - - void GuiGraphicsAnimationManager::Play() - { - for(vint i=playingAnimations.Count()-1;i>=0;i--) - { - Ptr animation=playingAnimations[i]; - vint totalLength=animation->GetTotalLength(); - vint currentPosition=animation->GetCurrentPosition(); - animation->Play(currentPosition, totalLength); - if(currentPosition>=totalLength) - { - playingAnimations.RemoveAt(i); - animation->Stop(); - } - } - } - -/*********************************************************************** -IGuiAltAction -***********************************************************************/ - - const wchar_t* const IGuiAltAction::Identifier = L"vl::presentation::compositions::IGuiAltAction"; - const wchar_t* const IGuiAltActionContainer::Identifier = L"vl::presentation::compositions::IGuiAltAction"; - const wchar_t* const IGuiAltActionHost::Identifier = L"vl::presentation::compositions::IGuiAltAction"; - - bool IGuiAltAction::IsLegalAlt(const WString& alt) - { - for (vint i = 0; i < alt.Length(); i++) - { - if (alt[i] < L'A' || L'Z' < alt[i]) - { - return false; - } - } - return true; - } - - void IGuiAltActionHost::CollectAltActionsFromControl(controls::GuiControl* control, collections::Group& actions) - { - List controls; - controls.Add(control); - vint current = 0; - - while (current < controls.Count()) - { - GuiControl* control = controls[current++]; - - if (auto container = control->QueryTypedService()) - { - vint count = container->GetAltActionCount(); - for (vint i = 0; i < count; i++) - { - auto action = container->GetAltAction(i); - actions.Add(action->GetAlt(), action); - } - continue; - } - else if (auto action = control->QueryTypedService()) - { - if (action->IsAltAvailable()) - { - if (action->IsAltEnabled()) - { - actions.Add(action->GetAlt(), action); - continue; - } - } - } - - vint count = control->GetChildrenCount(); - for (vint i = 0; i < count; i++) - { - controls.Add(control->GetChild(i)); - } - } - } - -/*********************************************************************** -GuiGraphicsHost -***********************************************************************/ - - void GuiGraphicsHost::EnterAltHost(IGuiAltActionHost* host) - { - ClearAltHost(); - - Group actions; - host->CollectAltActions(actions); - if (actions.Count() == 0) - { - CloseAltHost(); - return; - } - - host->OnActivatedAltHost(currentAltHost); - currentAltHost = host; - CreateAltTitles(actions); - } - - void GuiGraphicsHost::LeaveAltHost() - { - if (currentAltHost) - { - ClearAltHost(); - auto previousHost = currentAltHost->GetPreviousAltHost(); - currentAltHost->OnDeactivatedAltHost(); - currentAltHost = previousHost; - - if (currentAltHost) - { - Group actions; - currentAltHost->CollectAltActions(actions); - CreateAltTitles(actions); - } - } - } - - bool GuiGraphicsHost::EnterAltKey(wchar_t key) - { - currentAltPrefix += key; - vint index = currentActiveAltActions.Keys().IndexOf(currentAltPrefix); - if (index == -1) - { - if (FilterTitles() == 0) - { - currentAltPrefix = currentAltPrefix.Left(currentAltPrefix.Length() - 1); - FilterTitles(); - } - } - else - { - auto action = currentActiveAltActions.Values()[index]; - if (action->GetActivatingAltHost()) - { - EnterAltHost(action->GetActivatingAltHost()); - } - else - { - CloseAltHost(); - } - action->OnActiveAlt(); + GuiEventArgs arguments; + item->Executed.Execute(arguments); return true; } + + TextPos currentCaret=documentElement->GetCaretEnd(); + bool frontSide=documentElement->IsCaretEndPreferFrontSide(); + TextPos begin=documentElement->GetCaretBegin(); + TextPos end=documentElement->GetCaretEnd(); + + switch(code) + { + case VKEY_UP: + { + TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretMoveUp, frontSide); + Move(newCaret, shift, frontSide); + } + break; + case VKEY_DOWN: + { + TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretMoveDown, frontSide); + Move(newCaret, shift, frontSide); + } + break; + case VKEY_LEFT: + { + TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretMoveLeft, frontSide); + Move(newCaret, shift, frontSide); + } + break; + case VKEY_RIGHT: + { + TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretMoveRight, frontSide); + Move(newCaret, shift, frontSide); + } + break; + case VKEY_HOME: + { + TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretLineFirst, frontSide); + if(newCaret==currentCaret) + { + newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretFirst, frontSide); + } + Move(newCaret, shift, frontSide); + } + break; + case VKEY_END: + { + TextPos newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretLineLast, frontSide); + if(newCaret==currentCaret) + { + newCaret=documentElement->CalculateCaret(currentCaret, IGuiGraphicsParagraph::CaretLast, frontSide); + } + Move(newCaret, shift, frontSide); + } + break; + case VKEY_PRIOR: + { + } + break; + case VKEY_NEXT: + { + } + break; + case VKEY_BACK: + if(editMode==Editable) + { + if(begin==end) + { + ProcessKey(VKEY_LEFT, true, false); + } + Array text; + EditText(documentElement->GetCaretBegin(), documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide(), text); + return true; + } + break; + case VKEY_DELETE: + if(editMode==Editable) + { + if(begin==end) + { + ProcessKey(VKEY_RIGHT, true, false); + } + Array text; + EditText(documentElement->GetCaretBegin(), documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide(), text); + return true; + } + break; + case VKEY_RETURN: + if(editMode==Editable) + { + if(ctrl) + { + Array text(1); + text[0]=L"\r\n"; + EditText(documentElement->GetCaretBegin(), documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide(), text); + } + else + { + Array text(2); + EditText(documentElement->GetCaretBegin(), documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide(), text); + } + return true; + } + break; + } return false; } - void GuiGraphicsHost::LeaveAltKey() + void GuiDocumentCommonInterface::InstallDocumentViewer( + GuiControl* _sender, + compositions::GuiGraphicsComposition* _container, + compositions::GuiGraphicsComposition* eventComposition, + compositions::GuiGraphicsComposition* focusableComposition + ) { - if (currentAltPrefix.Length() >= 1) - { - currentAltPrefix = currentAltPrefix.Left(currentAltPrefix.Length() - 1); - } - FilterTitles(); + documentControl=_sender; + + documentElement=GuiDocumentElement::Create(); + documentElement->SetCallback(this); + + documentComposition=new GuiBoundsComposition; + documentComposition->SetOwnedElement(documentElement); + documentComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElement); + documentComposition->SetAlignmentToParent(Margin(5, 5, 5, 5)); + _container->AddChild(documentComposition); + + documentComposition->GetEventReceiver()->mouseMove.AttachMethod(this, &GuiDocumentCommonInterface::OnMouseMove); + documentComposition->GetEventReceiver()->leftButtonDown.AttachMethod(this, &GuiDocumentCommonInterface::OnMouseDown); + documentComposition->GetEventReceiver()->leftButtonUp.AttachMethod(this, &GuiDocumentCommonInterface::OnMouseUp); + documentComposition->GetEventReceiver()->mouseLeave.AttachMethod(this, &GuiDocumentCommonInterface::OnMouseLeave); + + _sender->FontChanged.AttachMethod(this, &GuiDocumentCommonInterface::OnFontChanged); + focusableComposition->GetEventReceiver()->caretNotify.AttachMethod(this, &GuiDocumentCommonInterface::OnCaretNotify); + focusableComposition->GetEventReceiver()->gotFocus.AttachMethod(this, &GuiDocumentCommonInterface::OnGotFocus); + focusableComposition->GetEventReceiver()->lostFocus.AttachMethod(this, &GuiDocumentCommonInterface::OnLostFocus); + focusableComposition->GetEventReceiver()->keyDown.AttachMethod(this, &GuiDocumentCommonInterface::OnKeyDown); + focusableComposition->GetEventReceiver()->charInput.AttachMethod(this, &GuiDocumentCommonInterface::OnCharInput); + + undoRedoProcessor->Setup(documentElement, documentComposition); + ActiveHyperlinkChanged.SetAssociatedComposition(eventComposition); + ActiveHyperlinkExecuted.SetAssociatedComposition(eventComposition); + SelectionChanged.SetAssociatedComposition(eventComposition); + UndoRedoChanged.SetAssociatedComposition(eventComposition); + ModifiedChanged.SetAssociatedComposition(eventComposition); + + undoRedoProcessor->UndoRedoChanged.Add(this, &GuiDocumentCommonInterface::InvokeUndoRedoChanged); + undoRedoProcessor->ModifiedChanged.Add(this, &GuiDocumentCommonInterface::InvokeModifiedChanged); + SetDocument(new DocumentModel); } - void GuiGraphicsHost::CreateAltTitles(const collections::Group& actions) + void GuiDocumentCommonInterface::SetActiveHyperlink(Ptr package) { - if (currentAltHost) - { - vint count = actions.Count(); - for (vint i = 0; i < count; i++) - { - WString key = actions.Keys()[i]; - const auto& values = actions.GetByIndex(i); - vint numberLength = 0; - if (values.Count() == 1 && key.Length() > 0) - { - numberLength = 0; - } - else if (values.Count() <= 10) - { - numberLength = 1; - } - else if (values.Count() <= 100) - { - numberLength = 2; - } - else if (values.Count() <= 1000) - { - numberLength = 3; - } - else - { - continue; - } + ActivateActiveHyperlink(false); + activeHyperlinks = + !package ? nullptr : + package->hyperlinks.Count() == 0 ? nullptr : + package; + ActivateActiveHyperlink(true); + ActiveHyperlinkChanged.Execute(documentControl->GetNotifyEventArguments()); + } - FOREACH_INDEXER(IGuiAltAction*, action, index, values) + void GuiDocumentCommonInterface::ActivateActiveHyperlink(bool activate) + { + if (activeHyperlinks) + { + FOREACH(Ptr, run, activeHyperlinks->hyperlinks) + { + run->styleName = activate ? run->activeStyleName : run->normalStyleName; + } + documentElement->NotifyParagraphUpdated(activeHyperlinks->row, 1, 1, false); + } + } + + void GuiDocumentCommonInterface::AddShortcutCommand(vint key, const Func& eventHandler) + { + IGuiShortcutKeyItem* item=internalShortcutKeyManager->CreateShortcut(true, false, false, key); + item->Executed.AttachLambda([=](GuiGraphicsComposition* sender, GuiEventArgs& arguments) + { + eventHandler(); + }); + } + + void GuiDocumentCommonInterface::EditTextInternal(TextPos begin, TextPos end, const Func& editor) + { + // save run before editing + if(begin>end) + { + TextPos temp=begin; + begin=end; + end=temp; + } + Ptr originalModel=documentElement->GetDocument()->CopyDocument(begin, end, true); + if(originalModel) + { + // edit + vint paragraphCount=0; + vint lastParagraphLength=0; + editor(begin, end, paragraphCount, lastParagraphLength); + + // calculate new caret + TextPos caret; + if(paragraphCount==0) + { + caret=begin; + } + else if(paragraphCount==1) + { + caret=TextPos(begin.row, begin.column+lastParagraphLength); + } + else + { + caret=TextPos(begin.row+paragraphCount-1, lastParagraphLength); + } + documentElement->SetCaret(caret, caret, true); + documentControl->TextChanged.Execute(documentControl->GetNotifyEventArguments()); + UpdateCaretPoint(); + SelectionChanged.Execute(documentControl->GetNotifyEventArguments()); + + // save run after editing + Ptr inputModel=documentElement->GetDocument()->CopyDocument(begin, caret, true); + + // submit redo-undo + GuiDocumentUndoRedoProcessor::ReplaceModelStruct arguments; + arguments.originalStart=begin; + arguments.originalEnd=end; + arguments.originalModel=originalModel; + arguments.inputStart=begin; + arguments.inputEnd=caret; + arguments.inputModel=inputModel; + undoRedoProcessor->OnReplaceModel(arguments); + } + } + + void GuiDocumentCommonInterface::EditStyleInternal(TextPos begin, TextPos end, const Func& editor) + { + // save run before editing + if(begin>end) + { + TextPos temp=begin; + begin=end; + end=temp; + } + Ptr originalModel=documentElement->GetDocument()->CopyDocument(begin, end, true); + if(originalModel) + { + // edit + editor(begin, end); + + // save run after editing + Ptr inputModel=documentElement->GetDocument()->CopyDocument(begin, end, true); + + // submit redo-undo + GuiDocumentUndoRedoProcessor::ReplaceModelStruct arguments; + arguments.originalStart=begin; + arguments.originalEnd=end; + arguments.originalModel=originalModel; + arguments.inputStart=begin; + arguments.inputEnd=end; + arguments.inputModel=inputModel; + undoRedoProcessor->OnReplaceModel(arguments); + } + } + + void GuiDocumentCommonInterface::MergeBaselineAndDefaultFont(Ptr document) + { + document->MergeDefaultFont(documentControl->GetFont()); + if (baselineDocument) + { + document->MergeBaselineStyles(baselineDocument); + } + } + + void GuiDocumentCommonInterface::OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + auto document = documentElement->GetDocument(); + MergeBaselineAndDefaultFont(document); + documentElement->SetDocument(document); + } + + void GuiDocumentCommonInterface::OnCaretNotify(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if(documentControl->GetVisuallyEnabled()) + { + if(editMode!=ViewOnly) + { + documentElement->SetCaretVisible(!documentElement->GetCaretVisible()); + } + } + } + + void GuiDocumentCommonInterface::OnGotFocus(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if(documentControl->GetVisuallyEnabled()) + { + if(editMode!=ViewOnly) + { + documentElement->SetCaretVisible(true); + UpdateCaretPoint(); + } + } + } + + void GuiDocumentCommonInterface::OnLostFocus(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if(documentControl->GetVisuallyEnabled()) + { + documentElement->SetCaretVisible(false); + } + } + + void GuiDocumentCommonInterface::OnKeyDown(compositions::GuiGraphicsComposition* sender, compositions::GuiKeyEventArgs& arguments) + { + if(documentControl->GetVisuallyEnabled()) + { + if(editMode!=ViewOnly) + { + if(ProcessKey(arguments.code, arguments.shift, arguments.ctrl)) { - WString key = actions.Keys()[i]; - if (numberLength > 0) + arguments.handled=true; + } + } + } + } + + void GuiDocumentCommonInterface::OnCharInput(compositions::GuiGraphicsComposition* sender, compositions::GuiCharEventArgs& arguments) + { + if(documentControl->GetVisuallyEnabled()) + { + if(editMode==Editable && arguments.code!=VKEY_ESCAPE && arguments.code!=VKEY_BACK && arguments.code!=VKEY_RETURN && !arguments.ctrl) + { + Array text(1); + text[0]=WString(arguments.code); + EditText(documentElement->GetCaretBegin(), documentElement->GetCaretEnd(), documentElement->IsCaretEndPreferFrontSide(), text); + } + } + } + + void GuiDocumentCommonInterface::OnMouseMove(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments) + { + if(documentControl->GetVisuallyEnabled()) + { + switch(editMode) + { + case ViewOnly: + { + auto package = documentElement->GetHyperlinkFromPoint({ arguments.x, arguments.y }); + bool handCursor = false; + + if(dragging) { - WString number = itow(index); - while (number.Length() < numberLength) + if(activeHyperlinks) { - number = L"0" + number; + if (package && CompareEnumerable(activeHyperlinks->hyperlinks, package->hyperlinks) == 0) + { + ActivateActiveHyperlink(true); + handCursor = true; + } + else + { + ActivateActiveHyperlink(false); + } } - key += number; } - currentActiveAltActions.Add(key, action); - } - } - - count = currentActiveAltActions.Count(); - auto window = dynamic_cast(currentAltHost->GetAltComposition()->GetRelatedControlHost()); - for (vint i = 0; i < count; i++) - { - auto key = currentActiveAltActions.Keys()[i]; - auto composition = currentActiveAltActions.Values()[i]->GetAltComposition(); - - auto label = new GuiLabel(theme::ThemeName::ShortcutKey); - if (auto labelStyle = window->GetControlTemplateObject()->GetShortcutKeyTemplate()) - { - label->SetControlTemplate(labelStyle); - } - label->SetText(key); - composition->AddChild(label->GetBoundsComposition()); - currentActiveAltTitles.Add(key, label); - } - - FilterTitles(); - } - } - - vint GuiGraphicsHost::FilterTitles() - { - vint count = currentActiveAltTitles.Count(); - vint visibles = 0; - for (vint i = 0; i < count; i++) - { - auto key = currentActiveAltTitles.Keys()[i]; - auto value = currentActiveAltTitles.Values()[i]; - if (key.Length() >= currentAltPrefix.Length() && key.Left(currentAltPrefix.Length()) == currentAltPrefix) - { - value->SetVisible(true); - if (currentAltPrefix.Length() <= key.Length()) - { - value->SetText( - key - .Insert(currentAltPrefix.Length(), L"[") - .Insert(currentAltPrefix.Length() + 2, L"]") - ); - } - else - { - value->SetText(key); - } - visibles++; - } - else - { - value->SetVisible(false); - } - } - return visibles; - } - - void GuiGraphicsHost::ClearAltHost() - { - FOREACH(GuiControl*, title, currentActiveAltTitles.Values()) - { - SafeDeleteControl(title); - } - currentActiveAltActions.Clear(); - currentActiveAltTitles.Clear(); - currentAltPrefix = L""; - } - - void GuiGraphicsHost::CloseAltHost() - { - ClearAltHost(); - while (currentAltHost) - { - currentAltHost->OnDeactivatedAltHost(); - currentAltHost = currentAltHost->GetPreviousAltHost(); - } - } - - void GuiGraphicsHost::RefreshRelatedHostRecord(INativeWindow* nativeWindow) - { - hostRecord.nativeWindow = nativeWindow; - hostRecord.renderTarget = nativeWindow ? GetGuiGraphicsResourceManager()->GetRenderTarget(nativeWindow) : nullptr; - windowComposition->UpdateRelatedHostRecord(&hostRecord); - } - - void GuiGraphicsHost::DisconnectCompositionInternal(GuiGraphicsComposition* composition) - { - for(vint i=0;iChildren().Count();i++) - { - DisconnectCompositionInternal(composition->Children().Get(i)); - } - if(mouseCaptureComposition==composition) - { - if(hostRecord.nativeWindow) - { - hostRecord.nativeWindow->ReleaseCapture(); - } - mouseCaptureComposition=0; - } - if(focusedComposition==composition) - { - focusedComposition=0; - } - mouseEnterCompositions.Remove(composition); - } - - void GuiGraphicsHost::MouseCapture(const NativeWindowMouseInfo& info) - { - if(hostRecord.nativeWindow && (info.left || info.middle || info.right)) - { - if(!hostRecord.nativeWindow->IsCapturing() && !info.nonClient) - { - hostRecord.nativeWindow->RequireCapture(); - mouseCaptureComposition=windowComposition->FindComposition(Point(info.x, info.y)); - } - } - } - - void GuiGraphicsHost::MouseUncapture(const NativeWindowMouseInfo& info) - { - if(hostRecord.nativeWindow && !(info.left || info.middle || info.right)) - { - hostRecord.nativeWindow->ReleaseCapture(); - mouseCaptureComposition=0; - } - } - - void GuiGraphicsHost::OnCharInput(const NativeWindowCharInfo& info, GuiGraphicsComposition* composition, GuiCharEvent GuiGraphicsEventReceiver::* eventReceiverEvent) - { - List compositions; - while(composition) - { - if(composition->HasEventReceiver()) - { - compositions.Add(composition); - } - composition=composition->GetParent(); - } - - GuiCharEventArgs arguments(composition); - (NativeWindowCharInfo&)arguments=info; - - for(vint i=compositions.Count()-1;i>=0;i--) - { - compositions[i]->GetEventReceiver()->previewCharInput.Execute(arguments); - if(arguments.handled) - { - return; - } - } - - for(vint i=0;iGetEventReceiver()->*eventReceiverEvent).Execute(arguments); - if(arguments.handled) - { - return; - } - } - } - - void GuiGraphicsHost::OnKeyInput(const NativeWindowKeyInfo& info, GuiGraphicsComposition* composition, GuiKeyEvent GuiGraphicsEventReceiver::* eventReceiverEvent) - { - List compositions; - while(composition) - { - if(composition->HasEventReceiver()) - { - compositions.Add(composition); - } - composition=composition->GetParent(); - } - - GuiKeyEventArgs arguments(composition); - (NativeWindowKeyInfo&)arguments=info; - - for(vint i=compositions.Count()-1;i>=0;i--) - { - compositions[i]->GetEventReceiver()->previewKey.Execute(arguments); - if(arguments.handled) - { - return; - } - } - - for(vint i=0;iGetEventReceiver()->*eventReceiverEvent).Execute(arguments); - if(arguments.handled) - { - return; - } - } - } - - void GuiGraphicsHost::RaiseMouseEvent(GuiMouseEventArgs& arguments, GuiGraphicsComposition* composition, GuiMouseEvent GuiGraphicsEventReceiver::* eventReceiverEvent) - { - arguments.compositionSource=composition; - arguments.eventSource=0; - vint x=arguments.x; - vint y=arguments.y; - - while(composition) - { - if(composition->HasEventReceiver()) - { - if(!arguments.eventSource) - { - arguments.eventSource=composition; - } - GuiGraphicsEventReceiver* eventReceiver=composition->GetEventReceiver(); - (eventReceiver->*eventReceiverEvent).Execute(arguments); - if(arguments.handled) - { - break; - } - } - - GuiGraphicsComposition* parent=composition->GetParent(); - if(parent) - { - Rect parentBounds=parent->GetBounds(); - Rect clientArea=parent->GetClientArea(); - Rect childBounds=composition->GetBounds(); - - x+=childBounds.x1+(clientArea.x1-parentBounds.x1); - y+=childBounds.y1+(clientArea.y1-parentBounds.y1); - arguments.x=x; - arguments.y=y; - } - composition=parent; - } - } - - void GuiGraphicsHost::OnMouseInput(const NativeWindowMouseInfo& info, GuiMouseEvent GuiGraphicsEventReceiver::* eventReceiverEvent) - { - GuiGraphicsComposition* composition=0; - if(mouseCaptureComposition) - { - composition=mouseCaptureComposition; - } - else - { - composition=windowComposition->FindComposition(Point(info.x, info.y)); - } - if(composition) - { - Rect bounds=composition->GetGlobalBounds(); - GuiMouseEventArgs arguments; - (NativeWindowMouseInfo&)arguments=info; - arguments.x-=bounds.x1; - arguments.y-=bounds.y1; - RaiseMouseEvent(arguments, composition, eventReceiverEvent); - } - } - - INativeWindowListener::HitTestResult GuiGraphicsHost::HitTest(Point location) - { - Rect bounds = hostRecord.nativeWindow->GetBounds(); - Rect clientBounds = hostRecord.nativeWindow->GetClientBoundsInScreen(); - Point clientLocation(location.x + bounds.x1 - clientBounds.x1, location.y + bounds.y1 - clientBounds.y1); - GuiGraphicsComposition* hitComposition = windowComposition->FindComposition(clientLocation); - while (hitComposition) - { - INativeWindowListener::HitTestResult result = hitComposition->GetAssociatedHitTestResult(); - if (result == INativeWindowListener::NoDecision) - { - hitComposition = hitComposition->GetParent(); - } - else - { - return result; - } - } - return INativeWindowListener::NoDecision; - } - - void GuiGraphicsHost::Moving(Rect& bounds, bool fixSizeOnly) - { - Rect oldBounds = hostRecord.nativeWindow->GetBounds(); - minSize = windowComposition->GetPreferredBounds().GetSize(); - Size minWindowSize = minSize + (oldBounds.GetSize() - hostRecord.nativeWindow->GetClientSize()); - if (bounds.Width() < minWindowSize.x) - { - if (fixSizeOnly) - { - if (bounds.Width() < minWindowSize.x) - { - bounds.x2 = bounds.x1 + minWindowSize.x; - } - } - else if (oldBounds.x1 != bounds.x1) - { - bounds.x1 = oldBounds.x2 - minWindowSize.x; - } - else if (oldBounds.x2 != bounds.x2) - { - bounds.x2 = oldBounds.x1 + minWindowSize.x; - } - } - if (bounds.Height() < minWindowSize.y) - { - if (fixSizeOnly) - { - if (bounds.Height() < minWindowSize.y) - { - bounds.y2 = bounds.y1 + minWindowSize.y; - } - } - else if (oldBounds.y1 != bounds.y1) - { - bounds.y1 = oldBounds.y2 - minWindowSize.y; - } - else if (oldBounds.y2 != bounds.y2) - { - bounds.y2 = oldBounds.y1 + minWindowSize.y; - } - } - } - - void GuiGraphicsHost::Moved() - { - Size size = hostRecord.nativeWindow->GetClientSize(); - if (previousClientSize != size) - { - previousClientSize = size; - minSize = windowComposition->GetPreferredBounds().GetSize(); - needRender = true; - } - } - - void GuiGraphicsHost::Paint() - { - if (!supressPaint) - { - needRender = true; - } - } - - void GuiGraphicsHost::LeftButtonDown(const NativeWindowMouseInfo& info) - { - CloseAltHost(); - MouseCapture(info); - OnMouseInput(info, &GuiGraphicsEventReceiver::leftButtonDown); - } - - void GuiGraphicsHost::LeftButtonUp(const NativeWindowMouseInfo& info) - { - OnMouseInput(info, &GuiGraphicsEventReceiver::leftButtonUp); - MouseUncapture(info); - } - - void GuiGraphicsHost::LeftButtonDoubleClick(const NativeWindowMouseInfo& info) - { - LeftButtonDown(info); - OnMouseInput(info, &GuiGraphicsEventReceiver::leftButtonDoubleClick); - } - - void GuiGraphicsHost::RightButtonDown(const NativeWindowMouseInfo& info) - { - CloseAltHost(); - MouseCapture(info); - OnMouseInput(info, &GuiGraphicsEventReceiver::rightButtonDown); - } - - void GuiGraphicsHost::RightButtonUp(const NativeWindowMouseInfo& info) - { - OnMouseInput(info, &GuiGraphicsEventReceiver::rightButtonUp); - MouseUncapture(info); - } - - void GuiGraphicsHost::RightButtonDoubleClick(const NativeWindowMouseInfo& info) - { - RightButtonDown(info); - OnMouseInput(info, &GuiGraphicsEventReceiver::rightButtonDoubleClick); - } - - void GuiGraphicsHost::MiddleButtonDown(const NativeWindowMouseInfo& info) - { - CloseAltHost(); - MouseCapture(info); - OnMouseInput(info, &GuiGraphicsEventReceiver::middleButtonDown); - } - - void GuiGraphicsHost::MiddleButtonUp(const NativeWindowMouseInfo& info) - { - OnMouseInput(info, &GuiGraphicsEventReceiver::middleButtonUp); - MouseUncapture(info); - } - - void GuiGraphicsHost::MiddleButtonDoubleClick(const NativeWindowMouseInfo& info) - { - MiddleButtonDown(info); - OnMouseInput(info, &GuiGraphicsEventReceiver::middleButtonDoubleClick); - } - - void GuiGraphicsHost::HorizontalWheel(const NativeWindowMouseInfo& info) - { - OnMouseInput(info, &GuiGraphicsEventReceiver::horizontalWheel); - } - - void GuiGraphicsHost::VerticalWheel(const NativeWindowMouseInfo& info) - { - OnMouseInput(info, &GuiGraphicsEventReceiver::verticalWheel); - } - - void GuiGraphicsHost::MouseMoving(const NativeWindowMouseInfo& info) - { - CompositionList newCompositions; - { - GuiGraphicsComposition* composition = windowComposition->FindComposition(Point(info.x, info.y)); - while (composition) - { - newCompositions.Insert(0, composition); - composition = composition->GetParent(); - } - } - - vint firstDifferentIndex = mouseEnterCompositions.Count(); - for (vint i = 0; i < mouseEnterCompositions.Count(); i++) - { - if (i == newCompositions.Count()) - { - firstDifferentIndex = newCompositions.Count(); - break; - } - if (mouseEnterCompositions[i] != newCompositions[i]) - { - firstDifferentIndex = i; - break; - } - } - - for (vint i = mouseEnterCompositions.Count() - 1; i >= firstDifferentIndex; i--) - { - GuiGraphicsComposition* composition = mouseEnterCompositions[i]; - if (composition->HasEventReceiver()) - { - composition->GetEventReceiver()->mouseLeave.Execute(GuiEventArgs(composition)); - } - } - - CopyFrom(mouseEnterCompositions, newCompositions); - for (vint i = firstDifferentIndex; i < mouseEnterCompositions.Count(); i++) - { - GuiGraphicsComposition* composition = mouseEnterCompositions[i]; - if (composition->HasEventReceiver()) - { - composition->GetEventReceiver()->mouseEnter.Execute(GuiEventArgs(composition)); - } - } - - INativeCursor* cursor = 0; - if (newCompositions.Count() > 0) - { - cursor = newCompositions[newCompositions.Count() - 1]->GetRelatedCursor(); - } - if (cursor) - { - hostRecord.nativeWindow->SetWindowCursor(cursor); - } - else - { - hostRecord.nativeWindow->SetWindowCursor(GetCurrentController()->ResourceService()->GetDefaultSystemCursor()); - } - - OnMouseInput(info, &GuiGraphicsEventReceiver::mouseMove); - } - - void GuiGraphicsHost::MouseEntered() - { - } - - void GuiGraphicsHost::MouseLeaved() - { - for(vint i=mouseEnterCompositions.Count()-1;i>=0;i--) - { - GuiGraphicsComposition* composition=mouseEnterCompositions[i]; - if(composition->HasEventReceiver()) - { - composition->GetEventReceiver()->mouseLeave.Execute(GuiEventArgs(composition)); - } - } - mouseEnterCompositions.Clear(); - } - - void GuiGraphicsHost::KeyDown(const NativeWindowKeyInfo& info) - { - if (!info.ctrl && !info.shift && currentAltHost) - { - if (info.code == VKEY_ESCAPE) - { - LeaveAltHost(); - return; - } - else if (info.code == VKEY_BACK) - { - LeaveAltKey(); - } - else if (VKEY_NUMPAD0 <= info.code && info.code <= VKEY_NUMPAD9) - { - if (EnterAltKey((wchar_t)(L'0' + (info.code - VKEY_NUMPAD0)))) - { - supressAltKey = info.code; - return; - } - } - else if (('0' <= info.code && info.code <= '9') || ('A' <= info.code && info.code <= 'Z')) - { - if (EnterAltKey((wchar_t)info.code)) - { - supressAltKey = info.code; - return; - } - } - } - - if (currentAltHost) - { - return; - } - - if(shortcutKeyManager && shortcutKeyManager->Execute(info)) - { - return; - } - if(focusedComposition && focusedComposition->HasEventReceiver()) - { - OnKeyInput(info, focusedComposition, &GuiGraphicsEventReceiver::keyDown); - } - } - - void GuiGraphicsHost::KeyUp(const NativeWindowKeyInfo& info) - { - if (!info.ctrl && !info.shift && info.code == supressAltKey) - { - supressAltKey = 0; - return; - } - - if(focusedComposition && focusedComposition->HasEventReceiver()) - { - OnKeyInput(info, focusedComposition, &GuiGraphicsEventReceiver::keyUp); - } - } - - void GuiGraphicsHost::SysKeyDown(const NativeWindowKeyInfo& info) - { - if (!info.ctrl && !info.shift && info.code == VKEY_MENU && !currentAltHost) - { - if (auto window = dynamic_cast(windowComposition->Children()[0]->GetRelatedControlHost())) - { - if (auto altHost = window->QueryTypedService()) - { - if (!altHost->GetPreviousAltHost()) + else { - EnterAltHost(altHost); + SetActiveHyperlink(package); + handCursor = activeHyperlinks; + } + + if(handCursor) + { + auto cursor = GetCurrentController()->ResourceService()->GetSystemCursor(INativeCursor::Hand); + documentComposition->SetAssociatedCursor(cursor); + } + else + { + documentComposition->SetAssociatedCursor(nullptr); } } - } - } - - if (currentAltHost) - { - return; - } - - if(focusedComposition && focusedComposition->HasEventReceiver()) - { - OnKeyInput(info, focusedComposition, &GuiGraphicsEventReceiver::systemKeyDown); - } - } - - void GuiGraphicsHost::SysKeyUp(const NativeWindowKeyInfo& info) - { - if (!info.ctrl && !info.shift && info.code == VKEY_MENU && hostRecord.nativeWindow) - { - if (hostRecord.nativeWindow) - { - hostRecord.nativeWindow->SupressAlt(); - } - } - - if (focusedComposition && focusedComposition->HasEventReceiver()) - { - OnKeyInput(info, focusedComposition, &GuiGraphicsEventReceiver::systemKeyUp); - } - } - - void GuiGraphicsHost::Char(const NativeWindowCharInfo& info) - { - if (!currentAltHost && !supressAltKey) - { - if(focusedComposition && focusedComposition->HasEventReceiver()) - { - OnCharInput(info, focusedComposition, &GuiGraphicsEventReceiver::charInput); - } - } - } - - void GuiGraphicsHost::GlobalTimer() - { - if(animationManager.HasAnimation()) - { - animationManager.Play(); - } - - DateTime now=DateTime::UtcTime(); - if(now.totalMilliseconds-lastCaretTime>=CaretInterval) - { - lastCaretTime=now.totalMilliseconds; - if(focusedComposition && focusedComposition->HasEventReceiver()) - { - focusedComposition->GetEventReceiver()->caretNotify.Execute(GuiEventArgs(focusedComposition)); - } - } - - Render(false); - } - - GuiGraphicsHost::GuiGraphicsHost() - :shortcutKeyManager(0) - ,windowComposition(0) - ,focusedComposition(0) - ,mouseCaptureComposition(0) - ,lastCaretTime(0) - ,currentAltHost(0) - ,supressAltKey(0) - { - hostRecord.host = this; - windowComposition=new GuiWindowComposition; - windowComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); - RefreshRelatedHostRecord(nullptr); - } - - GuiGraphicsHost::~GuiGraphicsHost() - { - NotifyFinalizeInstance(windowComposition); - if(shortcutKeyManager) - { - delete shortcutKeyManager; - shortcutKeyManager=0; - } - delete windowComposition; - } - - INativeWindow* GuiGraphicsHost::GetNativeWindow() - { - return hostRecord.nativeWindow; - } - - void GuiGraphicsHost::SetNativeWindow(INativeWindow* _nativeWindow) - { - if (hostRecord.nativeWindow != _nativeWindow) - { - if (hostRecord.nativeWindow) - { - GetCurrentController()->CallbackService()->UninstallListener(this); - hostRecord.nativeWindow->UninstallListener(this); - } - - if (_nativeWindow) - { - _nativeWindow->InstallListener(this); - GetCurrentController()->CallbackService()->InstallListener(this); - previousClientSize = _nativeWindow->GetClientSize(); - minSize = windowComposition->GetPreferredBounds().GetSize(); - _nativeWindow->SetCaretPoint(caretPoint); - needRender = true; - } - - RefreshRelatedHostRecord(_nativeWindow); - } - } - - GuiGraphicsComposition* GuiGraphicsHost::GetMainComposition() - { - return windowComposition; - } - - void GuiGraphicsHost::Render(bool forceUpdate) - { - if (!forceUpdate && !needRender) - { - return; - } - needRender = false; - - if(hostRecord.nativeWindow && hostRecord.nativeWindow->IsVisible()) - { - supressPaint = true; - hostRecord.renderTarget->StartRendering(); - windowComposition->Render(Size()); - auto result = hostRecord.renderTarget->StopRendering(); - hostRecord.nativeWindow->RedrawContent(); - supressPaint = false; - - switch (result) - { - case RenderTargetFailure::ResizeWhileRendering: + break; + case Selectable: + case Editable: + if(dragging) { - GetGuiGraphicsResourceManager()->ResizeRenderTarget(hostRecord.nativeWindow); - needRender = true; + TextPos caret=documentElement->CalculateCaretFromPoint(Point(arguments.x, arguments.y)); + TextPos oldCaret=documentElement->GetCaretBegin(); + Move(caret, true, (oldCaret==caret?documentElement->IsCaretEndPreferFrontSide():caretGetVisuallyEnabled()) + { + documentControl->SetFocus(); + switch(editMode) + { + case ViewOnly: + SetActiveHyperlink(documentElement->GetHyperlinkFromPoint({ arguments.x, arguments.y })); + break; + case Selectable: + case Editable: { - windowComposition->UpdateRelatedHostRecord(nullptr); - GetGuiGraphicsResourceManager()->RecreateRenderTarget(hostRecord.nativeWindow); - RefreshRelatedHostRecord(hostRecord.nativeWindow); - needRender = true; + TextPos caret=documentElement->CalculateCaretFromPoint(Point(arguments.x, arguments.y)); + TextPos oldCaret=documentElement->GetCaretEnd(); + if(caret!=oldCaret) + { + Move(caret, arguments.shift, caretGetVisuallyEnabled()) + { + dragging=false; + switch(editMode) + { + case ViewOnly: + { + auto package = documentElement->GetHyperlinkFromPoint({ arguments.x, arguments.y }); + if(activeHyperlinks) + { + if (package && CompareEnumerable(activeHyperlinks->hyperlinks, package->hyperlinks) == 0) + { + ActiveHyperlinkExecuted.Execute(documentControl->GetNotifyEventArguments()); + } + else + { + SetActiveHyperlink(nullptr); + } + } } break; default:; @@ -25959,244 +25526,681 @@ GuiGraphicsHost } } - void GuiGraphicsHost::RequestRender() + void GuiDocumentCommonInterface::OnMouseLeave(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - needRender = true; + SetActiveHyperlink(0); } - IGuiShortcutKeyManager* GuiGraphicsHost::GetShortcutKeyManager() + Point GuiDocumentCommonInterface::GetDocumentViewPosition() { - return shortcutKeyManager; + return Point(0, 0); } - void GuiGraphicsHost::SetShortcutKeyManager(IGuiShortcutKeyManager* value) + void GuiDocumentCommonInterface::EnsureRectVisible(Rect bounds) { - shortcutKeyManager=value; } - bool GuiGraphicsHost::SetFocus(GuiGraphicsComposition* composition) + //================ callback + + void GuiDocumentCommonInterface::OnStartRender() { - if(!composition || composition->GetRelatedGraphicsHost()!=this) + FOREACH(Ptr, item, documentItems.Values()) + { + item->visible = false; + } + } + + void GuiDocumentCommonInterface::OnFinishRender() + { + FOREACH(Ptr, item, documentItems.Values()) + { + if (item->container->GetVisible() != item->visible) + { + item->container->SetVisible(item->visible); + } + } + } + + Size GuiDocumentCommonInterface::OnRenderEmbeddedObject(const WString& name, const Rect& location) + { + vint index = documentItems.Keys().IndexOf(name); + if (index != -1) + { + auto item = documentItems.Values()[index]; + auto size = item->container->GetBounds().GetSize(); + item->container->SetBounds(Rect(location.LeftTop(), Size(0, 0))); + item->visible = true; + return size; + } + return Size(); + } + + //================ basic + + GuiDocumentCommonInterface::GuiDocumentCommonInterface() + { + undoRedoProcessor=new GuiDocumentUndoRedoProcessor; + + internalShortcutKeyManager=new GuiShortcutKeyManager; + AddShortcutCommand('Z', Func(this, &GuiDocumentCommonInterface::Undo)); + AddShortcutCommand('Y', Func(this, &GuiDocumentCommonInterface::Redo)); + AddShortcutCommand('A', Func(this, &GuiDocumentCommonInterface::SelectAll)); + AddShortcutCommand('X', Func(this, &GuiDocumentCommonInterface::Cut)); + AddShortcutCommand('C', Func(this, &GuiDocumentCommonInterface::Copy)); + AddShortcutCommand('V', Func(this, &GuiDocumentCommonInterface::Paste)); + } + + GuiDocumentCommonInterface::~GuiDocumentCommonInterface() + { + } + + Ptr GuiDocumentCommonInterface::GetDocument() + { + return documentElement->GetDocument(); + } + + void GuiDocumentCommonInterface::SetDocument(Ptr value) + { + SetActiveHyperlink(0); + ClearUndoRedo(); + NotifyModificationSaved(); + + if (value) + { + if (value->paragraphs.Count() == 0) + { + value->paragraphs.Add(new DocumentParagraphRun); + } + MergeBaselineAndDefaultFont(value); + } + + documentElement->SetDocument(value); + } + + //================ document items + + bool GuiDocumentCommonInterface::AddDocumentItem(Ptr value) + { + if (documentItems.Keys().Contains(value->GetName())) { return false; } - if(focusedComposition && focusedComposition->HasEventReceiver()) - { - GuiEventArgs arguments; - arguments.compositionSource=focusedComposition; - arguments.eventSource=focusedComposition; - focusedComposition->GetEventReceiver()->lostFocus.Execute(arguments); - } - focusedComposition=composition; - SetCaretPoint(Point(0, 0)); - if(focusedComposition && focusedComposition->HasEventReceiver()) - { - GuiEventArgs arguments; - arguments.compositionSource=focusedComposition; - arguments.eventSource=focusedComposition; - focusedComposition->GetEventReceiver()->gotFocus.Execute(arguments); - } + documentItems.Add(value->GetName(), value); + documentComposition->AddChild(value->container); + value->visible = false; + value->owned = true; + value->container->SetVisible(false); return true; } - GuiGraphicsComposition* GuiGraphicsHost::GetFocusedComposition() + bool GuiDocumentCommonInterface::RemoveDocumentItem(Ptr value) { - return focusedComposition; - } - - Point GuiGraphicsHost::GetCaretPoint() - { - return caretPoint; - } - - void GuiGraphicsHost::SetCaretPoint(Point value, GuiGraphicsComposition* referenceComposition) - { - if (referenceComposition) + vint index = documentItems.Keys().IndexOf(value->GetName()); + if (index == -1) { - Rect bounds = referenceComposition->GetGlobalBounds(); - value.x += bounds.x1; - value.y += bounds.y1; + return false; } - caretPoint = value; - if (hostRecord.nativeWindow) + if (documentItems.Values()[index] != value) { - hostRecord.nativeWindow->SetCaretPoint(caretPoint); + return false; + } + value->owned = false; + documentComposition->RemoveChild(value->container); + documentItems.Remove(value->GetName()); + return true; + } + + const GuiDocumentCommonInterface::DocumentItemMap& GuiDocumentCommonInterface::GetDocumentItems() + { + return documentItems; + } + + //================ caret operations + + TextPos GuiDocumentCommonInterface::GetCaretBegin() + { + return documentElement->GetCaretBegin(); + } + + TextPos GuiDocumentCommonInterface::GetCaretEnd() + { + return documentElement->GetCaretEnd(); + } + + void GuiDocumentCommonInterface::SetCaret(TextPos begin, TextPos end) + { + documentElement->SetCaret(begin, end, end>=begin); + UpdateCaretPoint(); + SelectionChanged.Execute(documentControl->GetNotifyEventArguments()); + } + + TextPos GuiDocumentCommonInterface::CalculateCaretFromPoint(Point point) + { + return documentElement->CalculateCaretFromPoint(point); + } + + Rect GuiDocumentCommonInterface::GetCaretBounds(TextPos caret, bool frontSide) + { + return documentElement->GetCaretBounds(caret, frontSide); + } + + //================ editing operations + + void GuiDocumentCommonInterface::NotifyParagraphUpdated(vint index, vint oldCount, vint newCount, bool updatedText) + { + documentElement->NotifyParagraphUpdated(index, oldCount, newCount, updatedText); + } + + void GuiDocumentCommonInterface::EditRun(TextPos begin, TextPos end, Ptr model, bool copy) + { + EditTextInternal(begin, end, [=](TextPos begin, TextPos end, vint& paragraphCount, vint& lastParagraphLength) + { + documentElement->EditRun(begin, end, model, copy); + paragraphCount=model->paragraphs.Count(); + lastParagraphLength=paragraphCount==0?0:model->paragraphs[paragraphCount-1]->GetText(false).Length(); + }); + } + + void GuiDocumentCommonInterface::EditText(TextPos begin, TextPos end, bool frontSide, const collections::Array& text) + { + EditTextInternal(begin, end, [=, &text](TextPos begin, TextPos end, vint& paragraphCount, vint& lastParagraphLength) + { + documentElement->EditText(begin, end, frontSide, text); + paragraphCount=text.Count(); + lastParagraphLength=paragraphCount==0?0:text[paragraphCount-1].Length(); + }); + } + + void GuiDocumentCommonInterface::EditStyle(TextPos begin, TextPos end, Ptr style) + { + EditStyleInternal(begin, end, [=](TextPos begin, TextPos end) + { + documentElement->EditStyle(begin, end, style); + }); + } + + void GuiDocumentCommonInterface::EditImage(TextPos begin, TextPos end, Ptr image) + { + EditTextInternal(begin, end, [=](TextPos begin, TextPos end, vint& paragraphCount, vint& lastParagraphLength) + { + documentElement->EditImage(begin, end, image); + paragraphCount=1; + lastParagraphLength=wcslen(DocumentImageRun::RepresentationText); + }); + } + + void GuiDocumentCommonInterface::EditHyperlink(vint paragraphIndex, vint begin, vint end, const WString& reference, const WString& normalStyleName, const WString& activeStyleName) + { + EditStyleInternal(TextPos(paragraphIndex, begin), TextPos(paragraphIndex, end), [=](TextPos begin, TextPos end) + { + documentElement->EditHyperlink(begin.row, begin.column, end.column, reference, normalStyleName, activeStyleName); + }); + } + + void GuiDocumentCommonInterface::RemoveHyperlink(vint paragraphIndex, vint begin, vint end) + { + EditStyleInternal(TextPos(paragraphIndex, begin), TextPos(paragraphIndex, end), [=](TextPos begin, TextPos end) + { + documentElement->RemoveHyperlink(begin.row, begin.column, end.column); + }); + } + + void GuiDocumentCommonInterface::EditStyleName(TextPos begin, TextPos end, const WString& styleName) + { + EditStyleInternal(begin, end, [=](TextPos begin, TextPos end) + { + documentElement->EditStyleName(begin, end, styleName); + }); + } + + void GuiDocumentCommonInterface::RemoveStyleName(TextPos begin, TextPos end) + { + EditStyleInternal(begin, end, [=](TextPos begin, TextPos end) + { + documentElement->RemoveStyleName(begin, end); + }); + } + + void GuiDocumentCommonInterface::RenameStyle(const WString& oldStyleName, const WString& newStyleName) + { + documentElement->RenameStyle(oldStyleName, newStyleName); + + // submit redo-undo + GuiDocumentUndoRedoProcessor::RenameStyleStruct arguments; + arguments.oldStyleName=oldStyleName; + arguments.newStyleName=newStyleName; + undoRedoProcessor->OnRenameStyle(arguments); + } + + void GuiDocumentCommonInterface::ClearStyle(TextPos begin, TextPos end) + { + EditStyleInternal(begin, end, [=](TextPos begin, TextPos end) + { + documentElement->ClearStyle(begin, end); + }); + } + + Ptr GuiDocumentCommonInterface::SummarizeStyle(TextPos begin, TextPos end) + { + if (begin>end) + { + TextPos temp = begin; + begin = end; + end = temp; + } + return documentElement->SummarizeStyle(begin, end); + } + + void GuiDocumentCommonInterface::SetParagraphAlignments(TextPos begin, TextPos end, const collections::Array>& alignments) + { + vint first = begin.row; + vint last = end.row; + if (first > last) + { + vint temp = first; + first = last; + last = temp; + } + + Ptr document = documentElement->GetDocument(); + if (0 <= first && first < document->paragraphs.Count() && 0 <= last && last < document->paragraphs.Count() && last - first + 1 == alignments.Count()) + { + Ptr arguments = new GuiDocumentUndoRedoProcessor::SetAlignmentStruct; + arguments->start = first; + arguments->end = last; + arguments->originalAlignments.Resize(alignments.Count()); + arguments->inputAlignments.Resize(alignments.Count()); + for (vint i = first; i <= last; i++) + { + arguments->originalAlignments[i - first] = document->paragraphs[i]->alignment; + arguments->inputAlignments[i - first] = alignments[i - first]; + } + documentElement->SetParagraphAlignment(begin, end, alignments); + undoRedoProcessor->OnSetAlignment(arguments); } } - GuiGraphicsAnimationManager* GuiGraphicsHost::GetAnimationManager() + void GuiDocumentCommonInterface::SetParagraphAlignment(TextPos begin, TextPos end, Nullable alignment) { - return &animationManager; +#if defined VCZH_GCC && defined VCZH_64 +#define abs labs +#endif + Array> alignments(abs(begin.row - end.row) + 1); +#if defined VCZH_GCC && defined VCZH_64 +#undef abs +#endif + for (vint i = 0; i < alignments.Count(); i++) + { + alignments[i] = alignment; + } + SetParagraphAlignments(begin, end, alignments); } - void GuiGraphicsHost::DisconnectComposition(GuiGraphicsComposition* composition) + Nullable GuiDocumentCommonInterface::SummarizeParagraphAlignment(TextPos begin, TextPos end) { - DisconnectCompositionInternal(composition); + if (begin>end) + { + TextPos temp = begin; + begin = end; + end = temp; + } + return documentElement->SummarizeParagraphAlignment(begin, end); + } + + //================ editing control + + WString GuiDocumentCommonInterface::GetActiveHyperlinkReference() + { + return activeHyperlinks ? activeHyperlinks->hyperlinks[0]->reference : L""; + } + + GuiDocumentCommonInterface::EditMode GuiDocumentCommonInterface::GetEditMode() + { + return editMode; + } + + void GuiDocumentCommonInterface::SetEditMode(EditMode value) + { + if(activeHyperlinks) + { + SetActiveHyperlink(nullptr); + } + + editMode=value; + if(editMode==ViewOnly) + { + documentComposition->SetAssociatedCursor(0); + } + else + { + INativeCursor* cursor=GetCurrentController()->ResourceService()->GetSystemCursor(INativeCursor::IBeam); + documentComposition->SetAssociatedCursor(cursor); + } + } + + //================ selection operations + + void GuiDocumentCommonInterface::SelectAll() + { + vint lastIndex=documentElement->GetDocument()->paragraphs.Count()-1; + Ptr lastParagraph=documentElement->GetDocument()->paragraphs[lastIndex]; + + TextPos begin(0, 0); + TextPos end(lastIndex, lastParagraph->GetText(false).Length()); + SetCaret(begin, end); + } + + WString GuiDocumentCommonInterface::GetSelectionText() + { + TextPos begin=documentElement->GetCaretBegin(); + TextPos end=documentElement->GetCaretEnd(); + if(begin>end) + { + TextPos temp=begin; + begin=end; + end=temp; + } + + Ptr model=documentElement->GetDocument()->CopyDocument(begin, end, false); + return model->GetText(true); + } + + void GuiDocumentCommonInterface::SetSelectionText(const WString& value) + { + List paragraphs; + { + stream::StringReader reader(value); + WString paragraph; + bool empty=true; + + while(!reader.IsEnd()) + { + WString line=reader.ReadLine(); + if(empty) + { + paragraph+=line; + empty=false; + } + else if(line!=L"") + { + paragraph+=L"\r\n"+line; + } + else + { + paragraphs.Add(paragraph); + paragraph=L""; + empty=true; + } + } + + if(!empty) + { + paragraphs.Add(paragraph); + } + } + + TextPos begin=documentElement->GetCaretBegin(); + TextPos end=documentElement->GetCaretEnd(); + if(begin>end) + { + TextPos temp=begin; + begin=end; + end=temp; + } + + Array text; + CopyFrom(text, paragraphs); + EditText(begin, end, documentElement->IsCaretEndPreferFrontSide(), text); + } + + Ptr GuiDocumentCommonInterface::GetSelectionModel() + { + TextPos begin=documentElement->GetCaretBegin(); + TextPos end=documentElement->GetCaretEnd(); + if(begin>end) + { + TextPos temp=begin; + begin=end; + end=temp; + } + + Ptr model=documentElement->GetDocument()->CopyDocument(begin, end, true); + return model; + } + + void GuiDocumentCommonInterface::SetSelectionModel(Ptr value) + { + TextPos begin=documentElement->GetCaretBegin(); + TextPos end=documentElement->GetCaretEnd(); + if(begin>end) + { + TextPos temp=begin; + begin=end; + end=temp; + } + + EditRun(begin, end, value, true); + } + + //================ clipboard operations + + bool GuiDocumentCommonInterface::CanCut() + { + return editMode==Editable && documentElement->GetCaretBegin()!=documentElement->GetCaretEnd(); + } + + bool GuiDocumentCommonInterface::CanCopy() + { + return documentElement->GetCaretBegin()!=documentElement->GetCaretEnd(); + } + + bool GuiDocumentCommonInterface::CanPaste() + { + return editMode==Editable && GetCurrentController()->ClipboardService()->ContainsText(); + } + + bool GuiDocumentCommonInterface::Cut() + { + if(CanCut()) + { + GetCurrentController()->ClipboardService()->SetText(GetSelectionText()); + SetSelectionText(L""); + return true; + } + else + { + return false; + } + } + + bool GuiDocumentCommonInterface::Copy() + { + if(CanCopy()) + { + GetCurrentController()->ClipboardService()->SetText(GetSelectionText()); + return true; + } + else + { + return false; + } + } + + bool GuiDocumentCommonInterface::Paste() + { + if(CanPaste()) + { + SetSelectionText(GetCurrentController()->ClipboardService()->GetText()); + return true; + } + else + { + return false; + } + } + + //================ undo redo control + + bool GuiDocumentCommonInterface::CanUndo() + { + return editMode==Editable && undoRedoProcessor->CanUndo(); + } + + bool GuiDocumentCommonInterface::CanRedo() + { + return editMode==Editable && undoRedoProcessor->CanRedo(); + } + + void GuiDocumentCommonInterface::ClearUndoRedo() + { + undoRedoProcessor->ClearUndoRedo(); + } + + bool GuiDocumentCommonInterface::GetModified() + { + return undoRedoProcessor->GetModified(); + } + + void GuiDocumentCommonInterface::NotifyModificationSaved() + { + undoRedoProcessor->NotifyModificationSaved(); + } + + bool GuiDocumentCommonInterface::Undo() + { + if(CanUndo()) + { + return undoRedoProcessor->Undo(); + } + else + { + return false; + } + } + + bool GuiDocumentCommonInterface::Redo() + { + if(CanRedo()) + { + return undoRedoProcessor->Redo(); + } + else + { + return false; + } } /*********************************************************************** -GuiTimeBasedAnimation +GuiDocumentViewer ***********************************************************************/ - GuiTimeBasedAnimation::GuiTimeBasedAnimation(vint totalMilliseconds) - :startTime(0) - ,length(totalMilliseconds) - { - Restart(); - } - - GuiTimeBasedAnimation::~GuiTimeBasedAnimation() + void GuiDocumentViewer::BeforeControlTemplateUninstalled_() { } - void GuiTimeBasedAnimation::Restart(vint totalMilliseconds) + void GuiDocumentViewer::AfterControlTemplateInstalled_(bool initialize) { - startTime=DateTime::LocalTime().totalMilliseconds; - if(totalMilliseconds>-1) + auto ct = GetControlTemplateObject(); + baselineDocument = ct->GetBaselineDocument(); + if (documentElement) { - length=totalMilliseconds; + documentElement->SetCaretColor(ct->GetCaretColor()); + SetDocument(GetDocument()); } } - vint GuiTimeBasedAnimation::GetTotalLength() + Point GuiDocumentViewer::GetDocumentViewPosition() { - return length; + return GetViewBounds().LeftTop(); } - vint GuiTimeBasedAnimation::GetCurrentPosition() + void GuiDocumentViewer::EnsureRectVisible(Rect bounds) { - return (vint)(DateTime::LocalTime().totalMilliseconds-startTime); + Rect viewBounds=GetViewBounds(); + vint offset=0; + if(bounds.y1viewBounds.y2) + { + offset=bounds.y2-viewBounds.y2; + } + + GetVerticalScroll()->SetPosition(viewBounds.y1+offset); + } + + GuiDocumentViewer::GuiDocumentViewer(theme::ThemeName themeName) + :GuiScrollContainer(themeName) + { + SetExtendToFullWidth(true); + SetHorizontalAlwaysVisible(false); + SetFocusableComposition(boundsComposition); + InstallDocumentViewer(this, containerComposition, boundsComposition, focusableComposition); + } + + GuiDocumentViewer::~GuiDocumentViewer() + { + } + + const WString& GuiDocumentViewer::GetText() + { + text=documentElement->GetDocument()->GetText(true); + return text; + } + + void GuiDocumentViewer::SetText(const WString& value) + { + SelectAll(); + SetSelectionText(value); } /*********************************************************************** -GuiShortcutKeyItem +GuiDocumentLabel ***********************************************************************/ - GuiShortcutKeyItem::GuiShortcutKeyItem(GuiShortcutKeyManager* _shortcutKeyManager, bool _ctrl, bool _shift, bool _alt, vint _key) - :shortcutKeyManager(_shortcutKeyManager) - ,ctrl(_ctrl) - ,shift(_shift) - ,alt(_alt) - ,key(_key) + void GuiDocumentLabel::BeforeControlTemplateUninstalled_() { } - GuiShortcutKeyItem::~GuiShortcutKeyItem() + void GuiDocumentLabel::AfterControlTemplateInstalled_(bool initialize) { - } - - IGuiShortcutKeyManager* GuiShortcutKeyItem::GetManager() - { - return shortcutKeyManager; - } - - WString GuiShortcutKeyItem::GetName() - { - WString name; - if(ctrl) name+=L"Ctrl+"; - if(shift) name+=L"Shift+"; - if(alt) name+=L"Alt+"; - name+=GetCurrentController()->InputService()->GetKeyName(key); - return name; - } - - bool GuiShortcutKeyItem::CanActivate(const NativeWindowKeyInfo& info) - { - return - info.ctrl==ctrl && - info.shift==shift && - info.alt==alt && - info.code==key; - } - - bool GuiShortcutKeyItem::CanActivate(bool _ctrl, bool _shift, bool _alt, vint _key) - { - return - _ctrl==ctrl && - _shift==shift && - _alt==alt && - _key==key; - } - -/*********************************************************************** -GuiShortcutKeyManager -***********************************************************************/ - - GuiShortcutKeyManager::GuiShortcutKeyManager() - { - } - - GuiShortcutKeyManager::~GuiShortcutKeyManager() - { - } - - vint GuiShortcutKeyManager::GetItemCount() - { - return shortcutKeyItems.Count(); - } - - IGuiShortcutKeyItem* GuiShortcutKeyManager::GetItem(vint index) - { - return shortcutKeyItems[index].Obj(); - } - - bool GuiShortcutKeyManager::Execute(const NativeWindowKeyInfo& info) - { - bool executed=false; - FOREACH(Ptr, item, shortcutKeyItems) + auto ct = GetControlTemplateObject(); + baselineDocument = ct->GetBaselineDocument(); + if (documentElement) { - if(item->CanActivate(info)) - { - GuiEventArgs arguments; - item->Executed.Execute(arguments); - executed=true; - } + documentElement->SetCaretColor(ct->GetCaretColor()); + SetDocument(GetDocument()); } - return executed; } - IGuiShortcutKeyItem* GuiShortcutKeyManager::CreateShortcut(bool ctrl, bool shift, bool alt, vint key) + GuiDocumentLabel::GuiDocumentLabel(theme::ThemeName themeName) + :GuiControl(themeName) { - FOREACH(Ptr, item, shortcutKeyItems) - { - if(item->CanActivate(ctrl, shift, alt, key)) - { - return item.Obj(); - } - } - Ptr item=new GuiShortcutKeyItem(this, ctrl, shift, alt, key); - shortcutKeyItems.Add(item); - return item.Obj(); + SetFocusableComposition(boundsComposition); + InstallDocumentViewer(this, containerComposition, boundsComposition, focusableComposition); } - bool GuiShortcutKeyManager::DestroyShortcut(bool ctrl, bool shift, bool alt, vint key) + GuiDocumentLabel::~GuiDocumentLabel() { - FOREACH(Ptr, item, shortcutKeyItems) - { - if(item->CanActivate(ctrl, shift, alt, key)) - { - shortcutKeyItems.Remove(item.Obj()); - return true; - } - } - return false; } - IGuiShortcutKeyItem* GuiShortcutKeyManager::TryGetShortcut(bool ctrl, bool shift, bool alt, vint key) + const WString& GuiDocumentLabel::GetText() { - FOREACH(Ptr, item, shortcutKeyItems) - { - if(item->CanActivate(ctrl, shift, alt, key)) - { - return item.Obj(); - } - } - return 0; + text=documentElement->GetDocument()->GetText(true); + return text; + } + + void GuiDocumentLabel::SetText(const WString& value) + { + SelectAll(); + SetSelectionText(value); } } } } + /*********************************************************************** .\CONTROLS\TEXTEDITORPACKAGE\LANGUAGESERVICE\GUILANGUAGEAUTOCOMPLETE.CPP ***********************************************************************/ @@ -31025,6 +31029,289 @@ Type Resolver Plugin } +/*********************************************************************** +.\CONTROLS\TOOLSTRIPPACKAGE\GUITOOLSTRIPMENU.CPP +***********************************************************************/ + +namespace vl +{ + namespace presentation + { + namespace controls + { + using namespace collections; + using namespace compositions; + +/*********************************************************************** +GuiToolstripCollection +***********************************************************************/ + + void GuiToolstripCollection::InvokeUpdateLayout() + { + if(contentCallback) + { + contentCallback->UpdateLayout(); + } + } + + void GuiToolstripCollection::OnInterestingMenuButtonPropertyChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + InvokeUpdateLayout(); + } + + bool GuiToolstripCollection::QueryInsert(vint index, GuiControl* const& child) + { + return true; + } + + bool GuiToolstripCollection::QueryRemove(vint index, GuiControl* const& child) + { + return true; + } + + void GuiToolstripCollection::BeforeInsert(vint index, GuiControl* const& child) + { + } + + void GuiToolstripCollection::BeforeRemove(vint index, GuiControl* const& child) + { + GuiStackItemComposition* stackItem = stackComposition->GetStackItems().Get(index); + stackComposition->RemoveChild(stackItem); + stackItem->RemoveChild(child->GetBoundsComposition()); + delete stackItem; + delete child; + InvokeUpdateLayout(); + } + + void GuiToolstripCollection::AfterInsert(vint index, GuiControl* const& child) + { + GuiStackItemComposition* stackItem=new GuiStackItemComposition; + child->GetBoundsComposition()->SetAlignmentToParent(Margin(0, 0, 0, 0)); + stackItem->AddChild(child->GetBoundsComposition()); + stackComposition->InsertChild(index, stackItem); + + GuiMenuButton* menuButton=dynamic_cast(child); + if(menuButton) + { + menuButton->TextChanged.AttachMethod(this, &GuiToolstripCollection::OnInterestingMenuButtonPropertyChanged); + menuButton->ShortcutTextChanged.AttachMethod(this, &GuiToolstripCollection::OnInterestingMenuButtonPropertyChanged); + } + InvokeUpdateLayout(); + } + + void GuiToolstripCollection::AfterRemove(vint index, vint count) + { + InvokeUpdateLayout(); + } + + GuiToolstripCollection::GuiToolstripCollection(IContentCallback* _contentCallback, compositions::GuiStackComposition* _stackComposition) + :contentCallback(_contentCallback) + ,stackComposition(_stackComposition) + { + } + + GuiToolstripCollection::~GuiToolstripCollection() + { + } + +/*********************************************************************** +GuiToolstripMenu +***********************************************************************/ + + void GuiToolstripMenu::UpdateLayout() + { + sharedSizeRootComposition->ForceCalculateSizeImmediately(); + } + + GuiToolstripMenu::GuiToolstripMenu(theme::ThemeName themeName, GuiControl* _owner) + :GuiMenu(themeName, _owner) + { + sharedSizeRootComposition = new GuiSharedSizeRootComposition(); + sharedSizeRootComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + sharedSizeRootComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + containerComposition->AddChild(sharedSizeRootComposition); + + stackComposition=new GuiStackComposition; + stackComposition->SetDirection(GuiStackComposition::Vertical); + stackComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + stackComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + sharedSizeRootComposition->AddChild(stackComposition); + + toolstripItems = new GuiToolstripCollection(this, stackComposition); + } + + GuiToolstripMenu::~GuiToolstripMenu() + { + } + + GuiToolstripCollection& GuiToolstripMenu::GetToolstripItems() + { + return *toolstripItems.Obj(); + } + +/*********************************************************************** +GuiToolstripMenuBar +***********************************************************************/ + + GuiToolstripMenuBar::GuiToolstripMenuBar(theme::ThemeName themeName) + :GuiMenuBar(themeName) + { + stackComposition=new GuiStackComposition; + stackComposition->SetDirection(GuiStackComposition::Horizontal); + stackComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + stackComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + containerComposition->AddChild(stackComposition); + + toolstripItems=new GuiToolstripCollection(0, stackComposition); + } + + GuiToolstripMenuBar::~GuiToolstripMenuBar() + { + } + + GuiToolstripCollection& GuiToolstripMenuBar::GetToolstripItems() + { + return *toolstripItems.Obj(); + } + +/*********************************************************************** +GuiToolstripToolBar +***********************************************************************/ + + GuiToolstripToolBar::GuiToolstripToolBar(theme::ThemeName themeName) + :GuiControl(themeName) + { + stackComposition=new GuiStackComposition; + stackComposition->SetDirection(GuiStackComposition::Horizontal); + stackComposition->SetAlignmentToParent(Margin(0, 0, 0, 0)); + stackComposition->SetMinSizeLimitation(GuiGraphicsComposition::LimitToElementAndChildren); + containerComposition->AddChild(stackComposition); + + toolstripItems=new GuiToolstripCollection(0, stackComposition); + } + + GuiToolstripToolBar::~GuiToolstripToolBar() + { + } + + GuiToolstripCollection& GuiToolstripToolBar::GetToolstripItems() + { + return *toolstripItems.Obj(); + } + +/*********************************************************************** +GuiToolstripButton +***********************************************************************/ + + void GuiToolstripButton::UpdateCommandContent() + { + if(command) + { + SetImage(command->GetImage()); + SetText(command->GetText()); + SetEnabled(command->GetEnabled()); + SetSelected(command->GetSelected()); + if(command->GetShortcut()) + { + SetShortcutText(command->GetShortcut()->GetName()); + } + else + { + SetShortcutText(L""); + } + } + else + { + SetImage(0); + SetText(L""); + SetEnabled(true); + SetSelected(false); + SetShortcutText(L""); + } + } + + void GuiToolstripButton::OnClicked(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + if(command) + { + command->Executed.ExecuteWithNewSender(arguments, sender); + } + } + + void GuiToolstripButton::OnCommandDescriptionChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) + { + UpdateCommandContent(); + } + + GuiToolstripButton::GuiToolstripButton(theme::ThemeName themeName) + :GuiMenuButton(themeName) + ,command(0) + { + Clicked.AttachMethod(this, &GuiToolstripButton::OnClicked); + } + + GuiToolstripButton::~GuiToolstripButton() + { + } + + GuiToolstripCommand* GuiToolstripButton::GetCommand() + { + return command; + } + + void GuiToolstripButton::SetCommand(GuiToolstripCommand* value) + { + if(command!=value) + { + if(command) + { + command->DescriptionChanged.Detach(descriptionChangedHandler); + } + command=0; + descriptionChangedHandler=0; + if(value) + { + command=value; + descriptionChangedHandler=command->DescriptionChanged.AttachMethod(this, &GuiToolstripButton::OnCommandDescriptionChanged); + } + UpdateCommandContent(); + } + } + + GuiToolstripMenu* GuiToolstripButton::GetToolstripSubMenu() + { + return dynamic_cast(GetSubMenu()); + } + + GuiToolstripMenu* GuiToolstripButton::EnsureToolstripSubMenu() + { + if (!GetSubMenu()) + { + CreateToolstripSubMenu({}); + } + return dynamic_cast(GetSubMenu()); + } + + void GuiToolstripButton::CreateToolstripSubMenu(TemplateProperty subMenuTemplate) + { + if (!subMenu) + { + auto newSubMenu = new GuiToolstripMenu(theme::ThemeName::Menu, this); + if (subMenuTemplate) + { + newSubMenu->SetControlTemplate(subMenuTemplate); + } + else + { + newSubMenu->SetControlTemplate(GetControlTemplateObject()->GetSubMenuTemplate()); + } + SetSubMenu(newSubMenu, true); + } + } + } + } +} + /*********************************************************************** .\GACUIREFLECTIONHELPER.CPP ***********************************************************************/ diff --git a/Import/GacUI.h b/Import/GacUI.h index 2855577a..6469b8be 100644 --- a/Import/GacUI.h +++ b/Import/GacUI.h @@ -6525,14 +6525,15 @@ Basic Construction CompositionList children; GuiGraphicsComposition* parent = nullptr; Ptr ownedElement; - bool visible; - MinSizeLimitation minSizeLimitation; + bool visible = true; + bool transparentToMouse = false; + MinSizeLimitation minSizeLimitation = MinSizeLimitation::NoLimit; Ptr eventReceiver; GraphicsHostRecord* relatedHostRecord = nullptr; controls::GuiControl* associatedControl = nullptr; INativeCursor* associatedCursor = nullptr; - INativeWindowListener::HitTestResult associatedHitTestResult; + INativeWindowListener::HitTestResult associatedHitTestResult = INativeWindowListener::NoDecision; Margin margin; Margin internalMargin; @@ -6613,7 +6614,14 @@ Basic Construction /// Find a deepest composition that under a specified location. If the location is inside a compsition but not hit any sub composition, this function will return this composition. /// The deepest composition that under a specified location. /// The specified location. - GuiGraphicsComposition* FindComposition(Point location); + /// Find a composition for mouse event, it will ignore all compositions that are transparent to mouse events. + GuiGraphicsComposition* FindComposition(Point location, bool forMouseEvent); + /// Get is this composition transparent to mouse events. + /// Returns true if this composition is transparent to mouse events, which means it just passes all mouse events to the composition under it. + bool GetTransparentToMouse(); + /// Set is the composition transparent to mouse events. + /// Set to true to make this composition transparent to mouse events. + void SetTransparentToMouse(bool value); /// Get the bounds in the top composition space. /// The bounds in the top composition space. Rect GetGlobalBounds(); @@ -8060,14 +8068,6 @@ namespace vl virtual void NotifyDateSelected() = 0; }; - /// A command executor for the style controller to change the control state. - class IScrollViewCommandExecutor : public virtual IDescriptable, public Description - { - public: - /// Called when the size of the content has been changed. - virtual void CalculateView() = 0; - }; - class GuiInstanceRootObject; /// @@ -8193,8 +8193,6 @@ Control Template public: GuiControlTemplate(); ~GuiControlTemplate(); - - virtual void Initialize(); #define GuiControlTemplate_PROPERTIES(F)\ F(GuiControlTemplate, compositions::GuiGraphicsComposition*, ContainerComposition)\ @@ -8395,47 +8393,19 @@ Scrollable Controls class GuiScrollViewTemplate : public GuiControlTemplate, public AggregatableDescription { - protected: - controls::GuiScroll* horizontalScroll = nullptr; - controls::GuiScroll* verticalScroll = nullptr; - compositions::GuiTableComposition* tableComposition = nullptr; - compositions::GuiCellComposition* containerCellComposition = nullptr; - compositions::GuiBoundsComposition* containerComposition = nullptr; - bool horizontalAlwaysVisible = true; - bool verticalAlwaysVisible = true; - - void UpdateTable(); public: GuiScrollViewTemplate(); ~GuiScrollViewTemplate(); #define GuiScrollViewTemplate_PROPERTIES(F)\ - F(GuiScrollViewTemplate, TemplateProperty, HScrollTemplate)\ - F(GuiScrollViewTemplate, TemplateProperty, VScrollTemplate)\ - F(GuiScrollViewTemplate, vint, DefaultScrollSize)\ - F(GuiScrollViewTemplate, controls::IScrollViewCommandExecutor*, Commands)\ + F(GuiScrollViewTemplate, controls::GuiScroll*, HorizontalScroll)\ + F(GuiScrollViewTemplate, controls::GuiScroll*, VerticalScroll)\ GuiScrollViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_DECL) - - void AdjustView(Size fullSize); - - controls::GuiScroll* GetHorizontalScroll(); - controls::GuiScroll* GetVerticalScroll(); - - bool GetHorizontalAlwaysVisible(); - void SetHorizontalAlwaysVisible(bool value); - bool GetVerticalAlwaysVisible(); - void SetVerticalAlwaysVisible(bool value); - - void Initialize()override; }; class GuiMultilineTextBoxTemplate : public GuiScrollViewTemplate, public AggregatableDescription { - protected: - elements::GuiColorizedTextElement* textElement; - compositions::GuiBoundsComposition* textComposition; - public: GuiMultilineTextBoxTemplate(); ~GuiMultilineTextBoxTemplate(); @@ -8543,60 +8513,16 @@ Date Controls class GuiDatePickerTemplate : public GuiControlTemplate, public AggregatableDescription { - protected: - static const vint DaysOfWeek = 7; - static const vint DayRows = 6; - static const vint DayRowStart = 2; - static const vint YearFirst = 1900; - static const vint YearLast = 2099; - - DateTime currentDate; - Locale dateLocale; - bool preventComboEvent; - bool preventButtonEvent; - - controls::GuiComboBoxListControl* comboYear; - controls::GuiTextList* listYears; - controls::GuiComboBoxListControl* comboMonth; - controls::GuiTextList* listMonths; - collections::Array labelDaysOfWeek; - collections::Array buttonDays; - collections::Array labelDays; - collections::Array dateDays; - - void SetDay(const DateTime& day, vint& index, bool currentMonth); - void DisplayMonth(vint year, vint month); - void SelectDay(vint day); - - void comboYearMonth_SelectedIndexChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); - void buttonDay_SelectedChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); - void OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); - void UpdateData(const DateTime& value, bool forceUpdate); - public: GuiDatePickerTemplate(); ~GuiDatePickerTemplate(); #define GuiDatePickerTemplate_PROPERTIES(F)\ F(GuiDatePickerTemplate, controls::IDatePickerCommandExecutor*, Commands)\ - F(GuiDatePickerTemplate, TemplateProperty, DateButtonTemplate)\ - F(GuiDatePickerTemplate, TemplateProperty, DateTextListTemplate)\ - F(GuiDatePickerTemplate, TemplateProperty, DateComboBoxTemplate)\ - F(GuiDatePickerTemplate, Color, BackgroundColor)\ - F(GuiDatePickerTemplate, Color, PrimaryTextColor)\ - F(GuiDatePickerTemplate, Color, SecondaryTextColor)\ + F(GuiDatePickerTemplate, Locale, DateLocale)\ + F(GuiDatePickerTemplate, DateTime, Date)\ GuiDatePickerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_DECL) - - compositions::GuiNotifyEvent DateLocaleChanged; - compositions::GuiNotifyEvent DateChanged; - - const Locale& GetDateLocale(); - void SetDateLocale(const Locale& value); - const DateTime& GetDate(); - void SetDate(const DateTime& value); - - void Initialize()override; }; class GuiDateComboBoxTemplate : public GuiComboBoxTemplate, public AggregatableDescription @@ -8619,10 +8545,8 @@ Item Template { protected: controls::GuiListControl* listControl = nullptr; - bool initialized = false; virtual void OnInitialize(); - public: GuiListItemTemplate(); ~GuiListItemTemplate(); @@ -8716,6 +8640,278 @@ Item Template #endif +/*********************************************************************** +.\CONTROLS\TEMPLATES\GUICOMMONTEMPLATES.H +***********************************************************************/ +/*********************************************************************** +Vczh Library++ 3.0 +Developer: Zihan Chen(vczh) +GacUI::Template System + +Interfaces: +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_CONTROLS_TEMPLATES_GUICOMMONTEMPLATES +#define VCZH_PRESENTATION_CONTROLS_TEMPLATES_GUICOMMONTEMPLATES + + +namespace vl +{ + namespace presentation + { + namespace templates + { + +/*********************************************************************** +GuiCommonDatePickerLook +***********************************************************************/ + + class GuiCommonDatePickerLook : public GuiTemplate, public Description + { + protected: + static const vint DaysOfWeek = 7; + static const vint DayRows = 6; + static const vint DayRowStart = 2; + static const vint YearFirst = 1900; + static const vint YearLast = 2099; + + Color backgroundColor; + Color primaryTextColor; + Color secondaryTextColor; + DateTime currentDate; + Locale dateLocale; + FontProperties font; + + TemplateProperty dateButtonTemplate; + TemplateProperty dateTextListTemplate; + TemplateProperty dateComboBoxTemplate; + + controls::IDatePickerCommandExecutor* commands = nullptr; + bool preventComboEvent = false; + bool preventButtonEvent = false; + + controls::GuiComboBoxListControl* comboYear; + controls::GuiTextList* listYears; + controls::GuiComboBoxListControl* comboMonth; + controls::GuiTextList* listMonths; + collections::Array labelDaysOfWeek; + collections::Array buttonDays; + collections::Array labelDays; + collections::Array dateDays; + + void SetDay(const DateTime& day, vint& index, bool currentMonth); + void DisplayMonth(vint year, vint month); + void SelectDay(vint day); + + void comboYearMonth_SelectedIndexChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); + void buttonDay_SelectedChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); + + public: + GuiCommonDatePickerLook(Color _backgroundColor, Color _primaryTextColor, Color _secondaryTextColor); + ~GuiCommonDatePickerLook(); + + compositions::GuiNotifyEvent DateChanged; + + controls::IDatePickerCommandExecutor* GetCommands(); + void SetCommands(controls::IDatePickerCommandExecutor* value); + TemplateProperty GetDateButtonTemplate(); + void SetDateButtonTemplate(const TemplateProperty& value); + TemplateProperty GetDateTextListTemplate(); + void SetDateTextListTemplate(const TemplateProperty& value); + TemplateProperty GetDateComboBoxTemplate(); + void SetDateComboBoxTemplate(const TemplateProperty& value); + + const Locale& GetDateLocale(); + void SetDateLocale(const Locale& value); + const DateTime& GetDate(); + void SetDate(const DateTime& value); + const FontProperties& GetFont(); + void SetFont(const FontProperties& value); + }; + +/*********************************************************************** +GuiCommonScrollViewLook +***********************************************************************/ + + class GuiCommonScrollViewLook : public GuiTemplate, public Description + { + protected: + controls::GuiScroll* horizontalScroll = nullptr; + controls::GuiScroll* verticalScroll = nullptr; + compositions::GuiTableComposition* tableComposition = nullptr; + compositions::GuiCellComposition* containerCellComposition = nullptr; + compositions::GuiBoundsComposition* containerComposition = nullptr; + + vint defaultScrollSize = 12; + TemplateProperty hScrollTemplate; + TemplateProperty vScrollTemplate; + + void UpdateTable(); + void hScroll_OnVisibleChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); + void vScroll_OnVisibleChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); + public: + GuiCommonScrollViewLook(vint _defaultScrollSize); + ~GuiCommonScrollViewLook(); + + controls::GuiScroll* GetHScroll(); + controls::GuiScroll* GetVScroll(); + compositions::GuiGraphicsComposition* GetContainerComposition(); + + TemplateProperty GetHScrollTemplate(); + void SetHScrollTemplate(const TemplateProperty& value); + TemplateProperty GetVScrollTemplate(); + void SetVScrollTemplate(const TemplateProperty& value); + }; + +/*********************************************************************** +GuiCommonScrollBehavior +***********************************************************************/ + + class GuiCommonScrollBehavior : public controls::GuiComponent, public Description + { + protected: + bool dragging = false; + Point location = { 0,0 }; + GuiScrollTemplate* scrollTemplate = nullptr; + + void SetScroll(vint totalPixels, vint newOffset); + void AttachHandle(compositions::GuiGraphicsComposition* handle); + public: + GuiCommonScrollBehavior(); + ~GuiCommonScrollBehavior(); + + void AttachScrollTemplate(GuiScrollTemplate* value); + void AttachDecreaseButton(controls::GuiButton* button); + void AttachIncreaseButton(controls::GuiButton* button); + void AttachHorizontalPartialView(compositions::GuiPartialViewComposition* partialView); + void AttachVerticalPartialView(compositions::GuiPartialViewComposition* partialView); + void AttachHorizontalTrackerHandle(compositions::GuiBoundsComposition* handle); + void AttachVerticalTrackerHandle(compositions::GuiBoundsComposition* handle); + + vint GetHorizontalTrackerHandlerPosition(compositions::GuiBoundsComposition* handle, vint totalSize, vint pageSize, vint position); + vint GetVerticalTrackerHandlerPosition(compositions::GuiBoundsComposition* handle, vint totalSize, vint pageSize, vint position); + }; + } + } +} + +#endif + +/*********************************************************************** +.\CONTROLS\TEMPLATES\GUITHEMESTYLEFACTORY.H +***********************************************************************/ +/*********************************************************************** +Vczh Library++ 3.0 +Developer: Zihan Chen(vczh) +GacUI::Control Styles::Common Style Helpers + +Interfaces: +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_CONTROLS_GUITHEMESTYLEFACTORY +#define VCZH_PRESENTATION_CONTROLS_GUITHEMESTYLEFACTORY + + +namespace vl +{ + namespace presentation + { + namespace theme + { +#define GUI_CONTROL_TEMPLATE_TYPES(F) \ + F(WindowTemplate, Window) \ + F(ControlTemplate, CustomControl) \ + F(WindowTemplate, Tooltip) \ + F(LabelTemplate, Label) \ + F(LabelTemplate, ShortcutKey) \ + F(ScrollViewTemplate, ScrollView) \ + F(ControlTemplate, GroupBox) \ + F(TabTemplate, Tab) \ + F(ComboBoxTemplate, ComboBox) \ + F(MultilineTextBoxTemplate, MultilineTextBox) \ + F(SinglelineTextBoxTemplate, SinglelineTextBox) \ + F(DocumentViewerTemplate, DocumentViewer) \ + F(DocumentLabelTemplate, DocumentLabel) \ + F(DocumentLabelTemplate, DocumentTextBox) \ + F(ListViewTemplate, ListView) \ + F(TreeViewTemplate, TreeView) \ + F(TextListTemplate, TextList) \ + F(SelectableButtonTemplate, ListItemBackground) \ + F(SelectableButtonTemplate, TreeItemExpander) \ + F(SelectableButtonTemplate, CheckTextListItem) \ + F(SelectableButtonTemplate, RadioTextListItem) \ + F(MenuTemplate, Menu) \ + F(ControlTemplate, MenuBar) \ + F(ControlTemplate, MenuSplitter) \ + F(ToolstripButtonTemplate, MenuBarButton) \ + F(ToolstripButtonTemplate, MenuItemButton) \ + F(ControlTemplate, ToolstripToolBar) \ + F(ToolstripButtonTemplate, ToolstripButton) \ + F(ToolstripButtonTemplate, ToolstripDropdownButton) \ + F(ToolstripButtonTemplate, ToolstripSplitButton) \ + F(ControlTemplate, ToolstripSplitter) \ + F(ButtonTemplate, Button) \ + F(SelectableButtonTemplate, CheckBox) \ + F(SelectableButtonTemplate, RadioButton) \ + F(DatePickerTemplate, DatePicker) \ + F(ScrollTemplate, HScroll) \ + F(ScrollTemplate, VScroll) \ + F(ScrollTemplate, HTracker) \ + F(ScrollTemplate, VTracker) \ + F(ScrollTemplate, ProgressBar) \ + + enum class ThemeName + { + Unknown, +#define GUI_DEFINE_THEME_NAME(TEMPLATE, CONTROL) CONTROL, + GUI_CONTROL_TEMPLATE_TYPES(GUI_DEFINE_THEME_NAME) +#undef GUI_DEFINE_THEME_NAME + }; + + /// Theme interface. A theme creates appropriate style controllers or style providers for default controls. Call [M:vl.presentation.theme.GetCurrentTheme] to access this interface. + class ITheme : public virtual IDescriptable, public Description + { + public: + virtual TemplateProperty CreateStyle(ThemeName themeName) = 0; + }; + + class Theme; + + /// Partial control template collections. [F:vl.presentation.theme.GetCurrentTheme] will returns an object, which walks through multiple registered [T:vl.presentation.theme.ThemeTemplates] to create a correct template object for a control. + class ThemeTemplates : public controls::GuiInstanceRootObject, public AggregatableDescription + { + friend class Theme; + protected: + ThemeTemplates* previous = nullptr; + ThemeTemplates* next = nullptr; + + public: + ~ThemeTemplates(); + +#define GUI_DEFINE_ITEM_PROPERTY(TEMPLATE, CONTROL) TemplateProperty CONTROL; + GUI_CONTROL_TEMPLATE_TYPES(GUI_DEFINE_ITEM_PROPERTY) +#undef GUI_DEFINE_ITEM_PROPERTY + }; + + /// Get the current theme style factory object. The default theme is [T:vl.presentation.win7.Win7Theme]. Call [M:vl.presentation.theme.SetCurrentTheme] to change the default theme. + /// The current theme style factory object. + extern ITheme* GetCurrentTheme(); + extern void InitializeTheme(); + extern void FinalizeTheme(); + /// Register a control template collection object. + /// The name of the theme. + /// The control template collection object. + extern bool RegisterTheme(const WString& name, Ptr theme); + /// Unregister a control template collection object. + /// The registered object. Returns null if it does not exist. + /// The name of the theme. + extern Ptr UnregisterTheme(const WString& name); + } + } +} + +#endif + /*********************************************************************** .\GRAPHICSELEMENT\GUIGRAPHICSHOST.H ***********************************************************************/ @@ -10177,20 +10373,7 @@ Scroll View using IEventHandler = compositions::IGuiGraphicsEventHandler; protected: - class CommandExecutor : public Object, public IScrollViewCommandExecutor - { - protected: - GuiScrollView* scrollView; - - public: - CommandExecutor(GuiScrollView* _scrollView); - ~CommandExecutor(); - - void CalculateView()override; - }; - - Ptr commandExecutor; - bool supressScrolling; + bool supressScrolling = false; Ptr hScrollHandler; Ptr vScrollHandler; Ptr hWheelHandler; @@ -10204,6 +10387,7 @@ Scroll View void OnHorizontalWheel(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments); void OnVerticalWheel(compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments); void CallUpdateView(); + void AdjustView(Size fullSize); /// Calculate the full size of the content. /// The full size of the content. @@ -11060,42 +11244,44 @@ List Control public: /// Called when an item arranger in installed to a . /// The list control. - virtual void AttachListControl(GuiListControl* value)=0; + virtual void AttachListControl(GuiListControl* value) = 0; /// Called when an item arranger in uninstalled from a . - virtual void DetachListControl()=0; + virtual void DetachListControl() = 0; /// Get the binded item arranger callback object. /// The binded item arranger callback object. - virtual IItemArrangerCallback* GetCallback()=0; + virtual IItemArrangerCallback* GetCallback() = 0; /// Bind the item arranger callback object. /// The item arranger callback object to bind. - virtual void SetCallback(IItemArrangerCallback* value)=0; + virtual void SetCallback(IItemArrangerCallback* value) = 0; /// Get the total size of all data controls. /// The total size. - virtual Size GetTotalSize()=0; + virtual Size GetTotalSize() = 0; /// Get the item style controller for an visible item index. If an item is not visible, it returns null. /// The item style controller. /// The item index. - virtual ItemStyle* GetVisibleStyle(vint itemIndex)=0; + virtual ItemStyle* GetVisibleStyle(vint itemIndex) = 0; /// Get the item index for an visible item style controller. If an item is not visible, it returns -1. /// The item index. /// The item style controller. - virtual vint GetVisibleIndex(ItemStyle* style)=0; + virtual vint GetVisibleIndex(ItemStyle* style) = 0; + /// Reload all visible items. + virtual void ReloadVisibleStyles() = 0; /// Called when the visible area of item container is changed. /// The new visible area. - virtual void OnViewChanged(Rect bounds)=0; + virtual void OnViewChanged(Rect bounds) = 0; /// Find the item by an base item and a key direction. /// The item index that is found. Returns -1 if this operation failed. /// The base item index. /// The key direction. - virtual vint FindItem(vint itemIndex, compositions::KeyDirection key)=0; + virtual vint FindItem(vint itemIndex, compositions::KeyDirection key) = 0; /// Adjust the view location to make an item visible. /// Returns true if this operation succeeded. /// The item index of the item to be made visible. - virtual bool EnsureItemVisible(vint itemIndex)=0; + virtual bool EnsureItemVisible(vint itemIndex) = 0; /// Get the adopted size for the view bounds. /// The adopted size, making the vids bounds just enough to display several items. /// The expected size, to provide a guidance. - virtual Size GetAdoptedSize(Size expectedSize)=0; + virtual Size GetAdoptedSize(Size expectedSize) = 0; }; protected: @@ -11184,6 +11370,7 @@ List Control friend class collections::ArrayBase>; collections::Dictionary> visibleStyles; + void OnClientBoundsChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); void OnVisuallyEnabledChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); void OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); void OnItemMouseEvent(compositions::GuiItemMouseEvent& itemEvent, ItemStyle* style, compositions::GuiGraphicsComposition* sender, compositions::GuiMouseEventArgs& arguments); @@ -11471,6 +11658,7 @@ Predefined ItemArranger Size GetTotalSize()override; GuiListControl::ItemStyle* GetVisibleStyle(vint itemIndex)override; vint GetVisibleIndex(GuiListControl::ItemStyle* style)override; + void ReloadVisibleStyles()override; void OnViewChanged(Rect bounds)override; }; @@ -15093,7 +15281,7 @@ ComboBox with GuiListControl GuiSelectableListControl* containedListControl = nullptr; ItemStyleProperty itemStyleProperty; templates::GuiTemplate* itemStyleController = nullptr; - + Ptr boundsChangedHandler; void BeforeControlTemplateUninstalled()override; void AfterControlTemplateInstalled(bool initialize)override; @@ -15102,10 +15290,12 @@ ComboBox with GuiListControl void RemoveStyleController(); void InstallStyleController(vint itemIndex); virtual void DisplaySelectedContent(vint itemIndex); + void AdoptSubMenuSize(); void OnTextChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); void OnFontChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); void OnVisuallyEnabledChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); void OnListControlAdoptedSizeInvalidated(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); + void OnListControlBoundsChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); void OnListControlSelectionChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments); public: /// Create a control with a specified style controller and a list control that will be put in the popup control to show all items. @@ -17092,124 +17282,6 @@ Toolstrip Component #endif -/*********************************************************************** -.\CONTROLS\STYLES\GUITHEMESTYLEFACTORY.H -***********************************************************************/ -/*********************************************************************** -Vczh Library++ 3.0 -Developer: Zihan Chen(vczh) -GacUI::Control Styles::Common Style Helpers - -Interfaces: -***********************************************************************/ - -#ifndef VCZH_PRESENTATION_CONTROLS_GUITHEMESTYLEFACTORY -#define VCZH_PRESENTATION_CONTROLS_GUITHEMESTYLEFACTORY - - - - - -namespace vl -{ - namespace presentation - { - namespace theme - { -#define GUI_CONTROL_TEMPLATE_TYPES(F) \ - F(WindowTemplate, Window) \ - F(ControlTemplate, CustomControl) \ - F(WindowTemplate, Tooltip) \ - F(LabelTemplate, Label) \ - F(LabelTemplate, ShortcutKey) \ - F(ScrollViewTemplate, ScrollView) \ - F(ControlTemplate, GroupBox) \ - F(TabTemplate, Tab) \ - F(ComboBoxTemplate, ComboBox) \ - F(MultilineTextBoxTemplate, MultilineTextBox) \ - F(SinglelineTextBoxTemplate, SinglelineTextBox) \ - F(DocumentViewerTemplate, DocumentViewer) \ - F(DocumentLabelTemplate, DocumentLabel) \ - F(DocumentLabelTemplate, DocumentTextBox) \ - F(ListViewTemplate, ListView) \ - F(TreeViewTemplate, TreeView) \ - F(TextListTemplate, TextList) \ - F(SelectableButtonTemplate, ListItemBackground) \ - F(SelectableButtonTemplate, TreeItemExpander) \ - F(SelectableButtonTemplate, CheckTextListItem) \ - F(SelectableButtonTemplate, RadioTextListItem) \ - F(MenuTemplate, Menu) \ - F(ControlTemplate, MenuBar) \ - F(ControlTemplate, MenuSplitter) \ - F(ToolstripButtonTemplate, MenuBarButton) \ - F(ToolstripButtonTemplate, MenuItemButton) \ - F(ControlTemplate, ToolstripToolBar) \ - F(ToolstripButtonTemplate, ToolstripButton) \ - F(ToolstripButtonTemplate, ToolstripDropdownButton) \ - F(ToolstripButtonTemplate, ToolstripSplitButton) \ - F(ControlTemplate, ToolstripSplitter) \ - F(ButtonTemplate, Button) \ - F(SelectableButtonTemplate, CheckBox) \ - F(SelectableButtonTemplate, RadioButton) \ - F(DatePickerTemplate, DatePicker) \ - F(ScrollTemplate, HScroll) \ - F(ScrollTemplate, VScroll) \ - F(ScrollTemplate, HTracker) \ - F(ScrollTemplate, VTracker) \ - F(ScrollTemplate, ProgressBar) \ - - enum class ThemeName - { - Unknown, -#define GUI_DEFINE_THEME_NAME(TEMPLATE, CONTROL) CONTROL, - GUI_CONTROL_TEMPLATE_TYPES(GUI_DEFINE_THEME_NAME) -#undef GUI_DEFINE_THEME_NAME - }; - - /// Theme interface. A theme creates appropriate style controllers or style providers for default controls. Call [M:vl.presentation.theme.GetCurrentTheme] to access this interface. - class ITheme : public virtual IDescriptable, public Description - { - public: - virtual TemplateProperty CreateStyle(ThemeName themeName) = 0; - }; - - class Theme; - - /// Partial control template collections. [F:vl.presentation.theme.GetCurrentTheme] will returns an object, which walks through multiple registered [T:vl.presentation.theme.ThemeTemplates] to create a correct template object for a control. - class ThemeTemplates : public controls::GuiInstanceRootObject, public AggregatableDescription - { - friend class Theme; - protected: - ThemeTemplates* previous = nullptr; - ThemeTemplates* next = nullptr; - - public: - ~ThemeTemplates(); - -#define GUI_DEFINE_ITEM_PROPERTY(TEMPLATE, CONTROL) TemplateProperty CONTROL; - GUI_CONTROL_TEMPLATE_TYPES(GUI_DEFINE_ITEM_PROPERTY) -#undef GUI_DEFINE_ITEM_PROPERTY - }; - - /// Get the current theme style factory object. The default theme is [T:vl.presentation.win7.Win7Theme]. Call [M:vl.presentation.theme.SetCurrentTheme] to change the default theme. - /// The current theme style factory object. - extern ITheme* GetCurrentTheme(); - extern void InitializeTheme(); - extern void FinalizeTheme(); - /// Register a control template collection object. - /// The name of the theme. - /// The control template collection object. - extern bool RegisterTheme(const WString& name, Ptr theme); - /// Unregister a control template collection object. - /// The registered object. Returns null if it does not exist. - /// The name of the theme. - extern Ptr UnregisterTheme(const WString& name); - } - } -} - -#endif - /*********************************************************************** .\RESOURCES\GUIDOCUMENTEDITOR.H ***********************************************************************/ diff --git a/Import/GacUICompiler.cpp b/Import/GacUICompiler.cpp index 93a83454..873252de 100644 --- a/Import/GacUICompiler.cpp +++ b/Import/GacUICompiler.cpp @@ -8431,6 +8431,10 @@ GuiCompositionInstanceLoader info->acceptableTypes.Add(TypeInfoRetriver::CreateTypeInfo()); info->acceptableTypes.Add(TypeInfoRetriver::CreateTypeInfo()); info->acceptableTypes.Add(TypeInfoRetriver>::CreateTypeInfo()); + if (propertyInfo.typeInfo.typeInfo->GetTypeDescriptor()->CanConvertTo(description::GetTypeDescriptor())) + { + info->acceptableTypes.Add(TypeInfoRetriver::CreateTypeInfo()); + } return info; } return IGuiInstanceLoader::GetPropertyType(propertyInfo); @@ -8449,7 +8453,22 @@ GuiCompositionInstanceLoader auto td = values[0].typeInfo->GetTypeDescriptor(); Ptr expr; - if (td->CanConvertTo(description::GetTypeDescriptor())) + if (td->CanConvertTo(description::GetTypeDescriptor())) + { + auto refControl = MakePtr(); + refControl->name.value = variableName.ToString(); + + auto refAddComponent = MakePtr(); + refAddComponent->parent = refControl; + refAddComponent->name.value = L"AddComponent"; + + auto call = MakePtr(); + call->function = refAddComponent; + call->arguments.Add(value); + + expr = call; + } + else if (td->CanConvertTo(description::GetTypeDescriptor())) { auto refComposition = MakePtr(); refComposition->name.value = variableName.ToString(); @@ -9937,18 +9956,24 @@ namespace vl { /*********************************************************************** -GuiTemplateInstanceLoader +GuiCommonDatePickerLookLoader ***********************************************************************/ - class GuiTemplateInstanceLoader : public Object, public IGuiInstanceLoader + class GuiCommonDatePickerLookLoader : public Object, public IGuiInstanceLoader { protected: GlobalStringKey typeName; + GlobalStringKey _BackgroundColor; + GlobalStringKey _PrimaryTextColor; + GlobalStringKey _SecondaryTextColor; public: - GuiTemplateInstanceLoader() + GuiCommonDatePickerLookLoader() { - typeName = GlobalStringKey::Get(description::TypeInfo::content.typeName); + typeName = GlobalStringKey::Get(description::TypeInfo::content.typeName); + _BackgroundColor = GlobalStringKey::Get(L"BackgroundColor"); + _PrimaryTextColor = GlobalStringKey::Get(L"PrimaryTextColor"); + _SecondaryTextColor = GlobalStringKey::Get(L"SecondaryTextColor"); } GlobalStringKey GetTypeName()override @@ -9958,35 +9983,145 @@ GuiTemplateInstanceLoader void GetRequiredPropertyNames(const TypeInfo& typeInfo, collections::List& propertyNames)override { - List tds; - tds.Add(typeInfo.typeInfo->GetTypeDescriptor()); - - for (vint i = 0; i < tds.Count(); i++) + if (CanCreate(typeInfo)) { - auto td = tds[i]; - if (td != description::GetTypeDescriptor()) - { - vint propCount = td->GetPropertyCount(); - for (vint i = 0; i < propCount; i++) - { - auto prop = td->GetProperty(i); - if (prop->IsWritable() && INVLOC.EndsWith(prop->GetName(), L"Template", Locale::None)) - { - propertyNames.Add(GlobalStringKey::Get(prop->GetName())); - } - } + propertyNames.Add(_BackgroundColor); + propertyNames.Add(_PrimaryTextColor); + propertyNames.Add(_SecondaryTextColor); + } + } - vint baseCount = td->GetBaseTypeDescriptorCount(); - for (vint i = 0; i < baseCount; i++) - { - auto baseTd = td->GetBaseTypeDescriptor(i); - if (!tds.Contains(baseTd)) - { - tds.Add(baseTd); - } - } + void GetPropertyNames(const TypeInfo& typeInfo, collections::List& propertyNames)override + { + GetRequiredPropertyNames(typeInfo, propertyNames); + } + + Ptr GetPropertyType(const PropertyInfo& propertyInfo)override + { + if (propertyInfo.propertyName == _BackgroundColor || propertyInfo.propertyName == _PrimaryTextColor || propertyInfo.propertyName == _SecondaryTextColor) + { + auto info = GuiInstancePropertyInfo::Assign(TypeInfoRetriver::CreateTypeInfo()); + info->usage = GuiInstancePropertyInfo::ConstructorArgument; + return info; + } + return IGuiInstanceLoader::GetPropertyType(propertyInfo); + } + + bool CanCreate(const TypeInfo& typeInfo) + { + return typeInfo.typeName == typeName; + } + + Ptr CreateInstance(GuiResourcePrecompileContext& precompileContext, types::ResolvingResult& resolvingResult, const TypeInfo& typeInfo, GlobalStringKey variableName, ArgumentMap& arguments, GuiResourceTextPos tagPosition, GuiResourceError::List& errors) + { + if (CanCreate(typeInfo)) + { + vint indexBackgroundColor = arguments.Keys().IndexOf(_BackgroundColor); + vint indexPrimaryTextColor = arguments.Keys().IndexOf(_PrimaryTextColor); + vint indexSecondaryTextColor = arguments.Keys().IndexOf(_SecondaryTextColor); + if (indexBackgroundColor != -1 && indexPrimaryTextColor != -1 && indexSecondaryTextColor != -1) + { + auto type = TypeInfoRetriver::CreateTypeInfo(); + auto createExpr = MakePtr(); + createExpr->type = GetTypeFromTypeInfo(type.Obj()); + createExpr->arguments.Add(arguments.GetByIndex(indexBackgroundColor)[0].expression); + createExpr->arguments.Add(arguments.GetByIndex(indexPrimaryTextColor)[0].expression); + createExpr->arguments.Add(arguments.GetByIndex(indexSecondaryTextColor)[0].expression); + + auto refVariable = MakePtr(); + refVariable->name.value = variableName.ToString(); + + auto assignExpr = MakePtr(); + assignExpr->op = WfBinaryOperator::Assign; + assignExpr->first = refVariable; + assignExpr->second = createExpr; + + auto assignStat = MakePtr(); + assignStat->expression = assignExpr; + return assignStat; } } + return nullptr; + } + }; + +/*********************************************************************** +GuiCommonScrollViewLookLoader +***********************************************************************/ + + class GuiCommonScrollViewLookLoader : public Object, public IGuiInstanceLoader + { + protected: + GlobalStringKey typeName; + GlobalStringKey _DefaultScrollSize; + + public: + GuiCommonScrollViewLookLoader() + { + typeName = GlobalStringKey::Get(description::TypeInfo::content.typeName); + _DefaultScrollSize = GlobalStringKey::Get(L"DefaultScrollSize"); + } + + GlobalStringKey GetTypeName()override + { + return typeName; + } + + void GetRequiredPropertyNames(const TypeInfo& typeInfo, collections::List& propertyNames)override + { + if (CanCreate(typeInfo)) + { + propertyNames.Add(_DefaultScrollSize); + } + } + + void GetPropertyNames(const TypeInfo& typeInfo, collections::List& propertyNames)override + { + GetRequiredPropertyNames(typeInfo, propertyNames); + } + + Ptr GetPropertyType(const PropertyInfo& propertyInfo)override + { + if (propertyInfo.propertyName == _DefaultScrollSize) + { + auto info = GuiInstancePropertyInfo::Assign(TypeInfoRetriver::CreateTypeInfo()); + info->usage = GuiInstancePropertyInfo::ConstructorArgument; + return info; + } + return IGuiInstanceLoader::GetPropertyType(propertyInfo); + } + + bool CanCreate(const TypeInfo& typeInfo) + { + return typeInfo.typeName == typeName; + } + + Ptr CreateInstance(GuiResourcePrecompileContext& precompileContext, types::ResolvingResult& resolvingResult, const TypeInfo& typeInfo, GlobalStringKey variableName, ArgumentMap& arguments, GuiResourceTextPos tagPosition, GuiResourceError::List& errors) + { + if (CanCreate(typeInfo)) + { + vint indexDefaultScrollSize = arguments.Keys().IndexOf(_DefaultScrollSize); + if (indexDefaultScrollSize != -1) + { + auto type = TypeInfoRetriver::CreateTypeInfo(); + auto createExpr = MakePtr(); + createExpr->type = GetTypeFromTypeInfo(type.Obj()); + createExpr->arguments.Add(arguments.GetByIndex(indexDefaultScrollSize)[0].expression); + + auto refVariable = MakePtr(); + refVariable->name.value = variableName.ToString(); + + auto assignExpr = MakePtr(); + assignExpr->op = WfBinaryOperator::Assign; + assignExpr->first = refVariable; + assignExpr->second = createExpr; + + auto assignStat = MakePtr(); + assignStat->expression = assignExpr; + return assignStat; + } + } + return nullptr; } }; @@ -9996,7 +10131,8 @@ Initialization void LoadTemplates(IGuiInstanceLoaderManager* manager) { - manager->SetLoader(new GuiTemplateInstanceLoader); + manager->SetLoader(new GuiCommonDatePickerLookLoader); + manager->SetLoader(new GuiCommonScrollViewLookLoader); } } } diff --git a/Import/GacUIReflection.cpp b/Import/GacUIReflection.cpp index 5cc14c83..493c31d2 100644 --- a/Import/GacUIReflection.cpp +++ b/Import/GacUIReflection.cpp @@ -897,6 +897,7 @@ Type Declaration CLASS_MEMBER_PROPERTY_FAST(Visible) CLASS_MEMBER_PROPERTY_FAST(MinSizeLimitation) CLASS_MEMBER_PROPERTY_READONLY_FAST(GlobalBounds) + CLASS_MEMBER_PROPERTY_FAST(TransparentToMouse) CLASS_MEMBER_PROPERTY_READONLY_FAST(AssociatedControl) CLASS_MEMBER_PROPERTY_FAST(AssociatedCursor) CLASS_MEMBER_PROPERTY_FAST(AssociatedHitTestResult) @@ -919,7 +920,7 @@ Type Declaration CLASS_MEMBER_METHOD(RemoveChild, {L"child"}) CLASS_MEMBER_METHOD(MoveChild, {L"child" _ L"newIndex"}) CLASS_MEMBER_METHOD(Render, {L"size"}) - CLASS_MEMBER_METHOD(FindComposition, {L"location"}) + CLASS_MEMBER_METHOD(FindComposition, {L"location" _ L"forMouseEvent"}) CLASS_MEMBER_METHOD(ForceCalculateSizeImmediately, NO_PARAMETER) CLASS_MEMBER_METHOD(IsSizeAffectParent, NO_PARAMETER) END_CLASS_MEMBER(GuiGraphicsComposition) @@ -1695,6 +1696,7 @@ Type Declaration CLASS_MEMBER_METHOD(DetachListControl, NO_PARAMETER) CLASS_MEMBER_METHOD(GetVisibleStyle, {L"itemIndex"}) CLASS_MEMBER_METHOD(GetVisibleIndex, {L"style"}) + CLASS_MEMBER_METHOD(ReloadVisibleStyles, NO_PARAMETER) CLASS_MEMBER_METHOD(OnViewChanged, {L"bounds"}) CLASS_MEMBER_METHOD(FindItem, {L"itemIndex" _ L"key"}) CLASS_MEMBER_METHOD(EnsureItemVisible, {L"itemIndex"}) @@ -3132,11 +3134,6 @@ Type Declaration CLASS_MEMBER_METHOD(NotifyDateSelected, NO_PARAMETER) END_INTERFACE_MEMBER(IDatePickerCommandExecutor) - BEGIN_INTERFACE_MEMBER_NOPROXY(IScrollViewCommandExecutor) - CLASS_MEMBER_BASE(IDescriptable) - CLASS_MEMBER_METHOD(CalculateView, NO_PARAMETER) - END_INTERFACE_MEMBER(IScrollViewCommandExecutor) - BEGIN_CLASS_MEMBER(GuiComponent) END_CLASS_MEMBER(GuiComponent) @@ -3167,7 +3164,6 @@ Type Declaration CLASS_MEMBER_BASE(BASE)\ CLASS_MEMBER_CONSTRUCTOR(NAME*(), NO_PARAMETER)\ NAME ## _PROPERTIES(GUI_TEMPLATE_PROPERTY_REFLECTION)\ - CLASS_MEMBER_METHOD(Initialize, NO_PARAMETER)\ END_CLASS_MEMBER(NAME)\ GUI_CONTROL_TEMPLATE(GuiControlTemplate, GuiTemplate) @@ -3184,35 +3180,13 @@ Type Declaration GUI_CONTROL_TEMPLATE(GuiListViewColumnHeaderTemplate, GuiToolstripButtonTemplate) GUI_CONTROL_TEMPLATE(GuiComboBoxTemplate, GuiToolstripButtonTemplate) GUI_CONTROL_TEMPLATE(GuiScrollTemplate, GuiControlTemplate) - - BEGIN_CLASS_MEMBER(GuiScrollViewTemplate) - CLASS_MEMBER_BASE(GuiControlTemplate) - CLASS_MEMBER_CONSTRUCTOR(GuiScrollViewTemplate*(), NO_PARAMETER) - - GuiScrollViewTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_REFLECTION) - - CLASS_MEMBER_METHOD(AdjustView, {L"fullSize"}) - CLASS_MEMBER_PROPERTY_READONLY_FAST(HorizontalScroll) - CLASS_MEMBER_PROPERTY_READONLY_FAST(VerticalScroll) - CLASS_MEMBER_PROPERTY_FAST(HorizontalAlwaysVisible) - CLASS_MEMBER_PROPERTY_FAST(VerticalAlwaysVisible) - END_CLASS_MEMBER(GuiScrollViewTemplate) - + GUI_CONTROL_TEMPLATE(GuiScrollViewTemplate, GuiControlTemplate) GUI_CONTROL_TEMPLATE(GuiListControlTemplate, GuiScrollViewTemplate) GUI_CONTROL_TEMPLATE(GuiTextListTemplate, GuiListControlTemplate) GUI_CONTROL_TEMPLATE(GuiListViewTemplate, GuiListControlTemplate) GUI_CONTROL_TEMPLATE(GuiTreeViewTemplate, GuiListControlTemplate) GUI_CONTROL_TEMPLATE(GuiTabTemplate, GuiControlTemplate) - - BEGIN_CLASS_MEMBER(GuiDatePickerTemplate) - CLASS_MEMBER_BASE(GuiControlTemplate) - CLASS_MEMBER_CONSTRUCTOR(GuiDatePickerTemplate*(), NO_PARAMETER) - - GuiDatePickerTemplate_PROPERTIES(GUI_TEMPLATE_PROPERTY_REFLECTION) - CLASS_MEMBER_PROPERTY_GUIEVENT_FAST(DateLocale) - CLASS_MEMBER_PROPERTY_GUIEVENT_FAST(Date) - END_CLASS_MEMBER(GuiDatePickerTemplate) - + GUI_CONTROL_TEMPLATE(GuiDatePickerTemplate, GuiControlTemplate) GUI_CONTROL_TEMPLATE(GuiDateComboBoxTemplate, GuiComboBoxTemplate) GUI_CONTROL_TEMPLATE(GuiListItemTemplate, GuiTemplate) GUI_CONTROL_TEMPLATE(GuiTextListItemTemplate, GuiListItemTemplate) @@ -3221,6 +3195,45 @@ Type Declaration GUI_CONTROL_TEMPLATE(GuiGridVisualizerTemplate, GuiGridCellTemplate) GUI_CONTROL_TEMPLATE(GuiGridEditorTemplate, GuiGridCellTemplate) + BEGIN_CLASS_MEMBER(GuiCommonDatePickerLook) + CLASS_MEMBER_BASE(GuiTemplate) + CLASS_MEMBER_CONSTRUCTOR(GuiCommonDatePickerLook*(Color, Color, Color), { L"backgroundColor" _ L"primaryTextColor" _ L"secondaryTextColor" }) + + CLASS_MEMBER_PROPERTY_FAST(Commands) + CLASS_MEMBER_PROPERTY_FAST(DateButtonTemplate) + CLASS_MEMBER_PROPERTY_FAST(DateTextListTemplate) + CLASS_MEMBER_PROPERTY_FAST(DateComboBoxTemplate) + CLASS_MEMBER_PROPERTY_FAST(DateLocale) + CLASS_MEMBER_PROPERTY_GUIEVENT_FAST(Date) + CLASS_MEMBER_PROPERTY_FAST(Font) + END_CLASS_MEMBER(GuiCommonDatePickerLook) + + BEGIN_CLASS_MEMBER(GuiCommonScrollViewLook) + CLASS_MEMBER_BASE(GuiTemplate) + CLASS_MEMBER_CONSTRUCTOR(GuiCommonScrollViewLook*(vint), { L"defaultScrollSize" }) + + CLASS_MEMBER_PROPERTY_FAST(HScrollTemplate) + CLASS_MEMBER_PROPERTY_FAST(VScrollTemplate) + CLASS_MEMBER_PROPERTY_READONLY_FAST(HScroll) + CLASS_MEMBER_PROPERTY_READONLY_FAST(VScroll) + CLASS_MEMBER_PROPERTY_READONLY_FAST(ContainerComposition) + END_CLASS_MEMBER(GuiCommonScrollViewLook) + + BEGIN_CLASS_MEMBER(GuiCommonScrollBehavior) + CLASS_MEMBER_BASE(GuiComponent) + CLASS_MEMBER_CONSTRUCTOR(GuiCommonScrollBehavior*(), NO_PARAMETER) + + CLASS_MEMBER_METHOD(AttachScrollTemplate, { L"value" }) + CLASS_MEMBER_METHOD(AttachDecreaseButton, { L"button" }) + CLASS_MEMBER_METHOD(AttachIncreaseButton, { L"button" }) + CLASS_MEMBER_METHOD(AttachHorizontalPartialView, { L"partialView" }) + CLASS_MEMBER_METHOD(AttachVerticalPartialView, { L"partialView" }) + CLASS_MEMBER_METHOD(AttachHorizontalTrackerHandle, { L"handle" }) + CLASS_MEMBER_METHOD(AttachVerticalTrackerHandle, { L"handle" }) + CLASS_MEMBER_METHOD(GetHorizontalTrackerHandlerPosition, { L"handle" _ L"totalSize" _ L"pageSize" _ L"position" }) + CLASS_MEMBER_METHOD(GetVerticalTrackerHandlerPosition, { L"handle" _ L"totalSize" _ L"pageSize" _ L"position" }) + END_CLASS_MEMBER(GuiCommonScrollBehavior) + #undef GUI_CONTROL_TEMPLATE #undef GUI_TEMPLATE_PROPERTY_REFLECTION #undef _ diff --git a/Import/GacUIReflection.h b/Import/GacUIReflection.h index 68518613..1ce1d47a 100644 --- a/Import/GacUIReflection.h +++ b/Import/GacUIReflection.h @@ -262,7 +262,6 @@ Type List (Templates) F(presentation::controls::IScrollCommandExecutor)\ F(presentation::controls::ITabCommandExecutor)\ F(presentation::controls::IDatePickerCommandExecutor)\ - F(presentation::controls::IScrollViewCommandExecutor)\ F(presentation::controls::GuiComponent)\ F(presentation::controls::GuiInstanceRootObject)\ F(presentation::templates::GuiTemplate)\ @@ -294,6 +293,9 @@ Type List (Templates) F(presentation::templates::GuiGridCellTemplate)\ F(presentation::templates::GuiGridVisualizerTemplate)\ F(presentation::templates::GuiGridEditorTemplate)\ + F(presentation::templates::GuiCommonDatePickerLook)\ + F(presentation::templates::GuiCommonScrollViewLook)\ + F(presentation::templates::GuiCommonScrollBehavior)\ /*********************************************************************** Type List (Controls) @@ -784,6 +786,11 @@ Interface Proxy (Controls) INVOKEGET_INTERFACE_PROXY(GetVisibleIndex, style); } + void ReloadVisibleStyles()override + { + INVOKE_INTERFACE_PROXY_NOPARAMS(ReloadVisibleStyles); + } + void OnViewChanged(presentation::Rect bounds)override { INVOKE_INTERFACE_PROXY(OnViewChanged, bounds); diff --git a/Import/Skins/DarkSkin/DarkSkin.cpp b/Import/Skins/DarkSkin/DarkSkin.cpp index 33322b15..0b33bdba 100644 --- a/Import/Skins/DarkSkin/DarkSkin.cpp +++ b/Import/Skins/DarkSkin/DarkSkin.cpp @@ -63,38 +63,38 @@ Closures //------------------------------------------------------------------- - __vwsnf100_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf100_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf100_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf100_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf100_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf100_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBorderColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7)->GetVisible(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBorderColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7)->SetVisible(__vwsn_new_); } //------------------------------------------------------------------- - __vwsnf101_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf101_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf101_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf101_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf101_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf101_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBackgroundColor(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_10.Obj())->GetBackgroundColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBackgroundColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_10.Obj())->SetBackgroundColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -104,11 +104,15 @@ Closures { } - ::vl::presentation::templates::GuiMenuTemplate* __vwsnf102_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + void __vwsnf102_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_10.Obj())->GetBorderColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) { - return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); + return; } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_10.Obj())->SetBorderColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -118,11 +122,15 @@ Closures { } - ::vl::presentation::templates::GuiControlTemplate* __vwsnf103_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + void __vwsnf103_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_9)->GetVisible(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ToolstripSplitArrowTemplate()); + return; } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_9)->SetVisible(__vwsn_new_); } //------------------------------------------------------------------- @@ -134,13 +142,13 @@ Closures void __vwsnf104_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_12.Obj())->GetText(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->SetColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_12.Obj())->SetText(__vwsn_new_); } //------------------------------------------------------------------- @@ -152,13 +160,13 @@ Closures void __vwsnf105_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7.Obj())->GetText(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_12.Obj())->GetColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7.Obj())->SetText(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_12.Obj())->SetColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -170,13 +178,13 @@ Closures void __vwsnf106_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7.Obj())->GetColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_12.Obj())->GetFont(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7.Obj())->SetColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_12.Obj())->SetFont(__vwsn_new_); } //------------------------------------------------------------------- @@ -187,24 +195,6 @@ Closures } void __vwsnf107_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7.Obj())->GetFont(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7.Obj())->SetFont(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf108_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf108_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf108_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->buttonArrow)->GetSelected(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -217,12 +207,12 @@ Closures //------------------------------------------------------------------- - __vwsnf109_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf109_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) + __vwsnf108_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf108_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf109_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf108_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->buttonArrow)->GetVisible(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -235,6 +225,20 @@ Closures //------------------------------------------------------------------- + __vwsnf109_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__::__vwsnf109_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + ::vl::presentation::templates::GuiListViewColumnHeaderTemplate* __vwsnf109_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + { + { + return static_cast<::vl::presentation::templates::GuiListViewColumnHeaderTemplate*>(new ::darkskin::ListViewColumnHeaderTemplate()); + } + } + + //------------------------------------------------------------------- + __vwsnf10_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf10_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::CheckBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -258,10 +262,10 @@ Closures { } - ::vl::presentation::templates::GuiListViewColumnHeaderTemplate* __vwsnf110_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + ::vl::presentation::templates::GuiSelectableButtonTemplate* __vwsnf110_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiListViewColumnHeaderTemplate*>(new ::darkskin::ListViewColumnHeaderTemplate()); + return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::ItemBackgroundTemplate()); } } @@ -272,10 +276,10 @@ Closures { } - ::vl::presentation::templates::GuiSelectableButtonTemplate* __vwsnf111_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + ::vl::presentation::templates::GuiScrollTemplate* __vwsnf111_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::ItemBackgroundTemplate()); + return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); } } @@ -289,21 +293,21 @@ Closures ::vl::presentation::templates::GuiScrollTemplate* __vwsnf112_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); + return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::HScrollTemplate()); } } //------------------------------------------------------------------- - __vwsnf113_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__::__vwsnf113_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewTemplateConstructor* __vwsnctorthis_0) + __vwsnf113_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf113_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - ::vl::presentation::templates::GuiScrollTemplate* __vwsnf113_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + ::vl::presentation::templates::GuiMenuTemplate* __vwsnf113_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::HScrollTemplate()); + return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); } } @@ -314,21 +318,7 @@ Closures { } - ::vl::presentation::templates::GuiMenuTemplate* __vwsnf114_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf115_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf115_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf115_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf114_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -341,12 +331,12 @@ Closures //------------------------------------------------------------------- - __vwsnf116_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf116_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf115_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf115_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf116_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf115_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetText(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); @@ -359,12 +349,12 @@ Closures //------------------------------------------------------------------- - __vwsnf117_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf117_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf116_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf116_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf117_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf116_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -377,12 +367,12 @@ Closures //------------------------------------------------------------------- - __vwsnf118_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf118_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf117_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf117_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf118_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf117_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetFont(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); @@ -395,16 +385,34 @@ Closures //------------------------------------------------------------------- + __vwsnf118_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf118_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + ::vl::presentation::templates::GuiMenuTemplate* __vwsnf118_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + { + { + return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); + } + } + + //------------------------------------------------------------------- + __vwsnf119_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf119_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - ::vl::presentation::templates::GuiMenuTemplate* __vwsnf119_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + void __vwsnf119_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) { - return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); + return; } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->SetColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -433,24 +441,6 @@ Closures } void __vwsnf120_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->SetColor(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf121_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf121_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf121_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetImage(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::Ptr<::vl::presentation::INativeImage>>(__vwsn_value_); @@ -463,12 +453,12 @@ Closures //------------------------------------------------------------------- - __vwsnf122_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf122_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf121_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf121_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf122_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf121_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetFrameIndex(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::vint>(__vwsn_value_); @@ -481,12 +471,12 @@ Closures //------------------------------------------------------------------- - __vwsnf123_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf123_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf122_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf122_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf123_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf122_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetEnabled(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -499,12 +489,12 @@ Closures //------------------------------------------------------------------- - __vwsnf124_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf124_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf123_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf123_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf124_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf123_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->GetText(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); @@ -517,12 +507,12 @@ Closures //------------------------------------------------------------------- - __vwsnf125_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf125_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf124_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf124_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf125_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf124_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -535,12 +525,12 @@ Closures //------------------------------------------------------------------- - __vwsnf126_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf126_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf125_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf125_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf126_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf125_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->GetFont(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); @@ -553,12 +543,12 @@ Closures //------------------------------------------------------------------- - __vwsnf127_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf127_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf126_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf126_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf127_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf126_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_9.Obj())->GetText(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); @@ -571,12 +561,12 @@ Closures //------------------------------------------------------------------- - __vwsnf128_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf128_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf127_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf127_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf128_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf127_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_9.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -589,12 +579,12 @@ Closures //------------------------------------------------------------------- - __vwsnf129_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf129_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf128_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf128_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf129_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf128_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_9.Obj())->GetFont(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); @@ -607,6 +597,24 @@ Closures //------------------------------------------------------------------- + __vwsnf129_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf129_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf129_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_11.Obj())->GetBackgroundColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_11.Obj())->SetBackgroundColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + __vwsnf12_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf12_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::CheckBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -649,24 +657,6 @@ Closures } void __vwsnf131_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_11.Obj())->GetBackgroundColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_11.Obj())->SetBackgroundColor(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf132_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf132_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf132_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_10)->GetVisible(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -679,26 +669,26 @@ Closures //------------------------------------------------------------------- + __vwsnf132_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf132_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::MultilineTextBoxTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + ::vl::presentation::templates::GuiScrollTemplate* __vwsnf132_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + { + { + return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); + } + } + + //------------------------------------------------------------------- + __vwsnf133_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf133_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::MultilineTextBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } ::vl::presentation::templates::GuiScrollTemplate* __vwsnf133_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf134_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf134_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::MultilineTextBoxTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiScrollTemplate* __vwsnf134_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::HScrollTemplate()); @@ -707,12 +697,12 @@ Closures //------------------------------------------------------------------- - __vwsnf135_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__::__vwsnf135_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__(::darkskin::ProgressBarTemplateConstructor* __vwsnctorthis_0) + __vwsnf134_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__::__vwsnf134_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__(::darkskin::ProgressBarTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf135_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf134_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3)->GetAlignmentToParent(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Margin>(__vwsn_value_); @@ -725,12 +715,12 @@ Closures //------------------------------------------------------------------- - __vwsnf136_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf136_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf135_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf135_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf136_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf135_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -743,12 +733,12 @@ Closures //------------------------------------------------------------------- - __vwsnf137_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf137_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf136_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf136_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf137_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf136_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_5.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -761,12 +751,12 @@ Closures //------------------------------------------------------------------- - __vwsnf138_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf138_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf137_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf137_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf138_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf137_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -779,12 +769,12 @@ Closures //------------------------------------------------------------------- - __vwsnf139_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf139_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf138_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf138_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf139_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf138_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6)->GetVisible(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -797,6 +787,24 @@ Closures //------------------------------------------------------------------- + __vwsnf139_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf139_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf139_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_10.Obj())->GetText(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_10.Obj())->SetText(__vwsn_new_); + } + + //------------------------------------------------------------------- + __vwsnf13_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf13_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::CheckBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -821,24 +829,6 @@ Closures } void __vwsnf140_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_10.Obj())->GetText(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_10.Obj())->SetText(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf141_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf141_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf141_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_10.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -851,12 +841,12 @@ Closures //------------------------------------------------------------------- - __vwsnf142_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf142_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf141_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf141_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf142_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf141_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_10.Obj())->GetFont(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); @@ -869,6 +859,24 @@ Closures //------------------------------------------------------------------- + __vwsnf142_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf142_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf142_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBackgroundColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBackgroundColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + __vwsnf143_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf143_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -887,20 +895,16 @@ Closures //------------------------------------------------------------------- - __vwsnf144_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf144_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf144_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__::__vwsnf144_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::ScrollViewTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf144_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + ::vl::presentation::templates::GuiScrollTemplate* __vwsnf144_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBackgroundColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) { - return; + return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBackgroundColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -911,20 +915,6 @@ Closures } ::vl::presentation::templates::GuiScrollTemplate* __vwsnf145_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf146_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__::__vwsnf146_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::ScrollViewTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiScrollTemplate* __vwsnf146_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::HScrollTemplate()); @@ -933,12 +923,12 @@ Closures //------------------------------------------------------------------- - __vwsnf147_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::__vwsnf147_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) + __vwsnf146_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::__vwsnf146_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf147_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf146_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetText(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); @@ -951,12 +941,12 @@ Closures //------------------------------------------------------------------- - __vwsnf148_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::__vwsnf148_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) + __vwsnf147_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::__vwsnf147_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf148_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf147_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -969,12 +959,12 @@ Closures //------------------------------------------------------------------- - __vwsnf149_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::__vwsnf149_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) + __vwsnf148_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::__vwsnf148_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf149_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf148_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetFont(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); @@ -987,6 +977,24 @@ Closures //------------------------------------------------------------------- + __vwsnf149_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf149_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf149_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->SetColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + __vwsnf14_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf14_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::CheckBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -1011,24 +1019,6 @@ Closures } void __vwsnf150_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->SetColor(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf151_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf151_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf151_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetText(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); @@ -1041,12 +1031,12 @@ Closures //------------------------------------------------------------------- - __vwsnf152_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf152_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf151_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf151_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf152_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf151_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -1059,12 +1049,12 @@ Closures //------------------------------------------------------------------- - __vwsnf153_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf153_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf152_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf152_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf153_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf152_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetFont(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); @@ -1077,12 +1067,12 @@ Closures //------------------------------------------------------------------- - __vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) + __vwsnf153_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf153_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - ::vl::presentation::templates::GuiControlTemplate* __vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + ::vl::presentation::templates::GuiControlTemplate* __vwsnf153_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::TabHeaderButtonTemplate()); @@ -1091,12 +1081,12 @@ Closures //------------------------------------------------------------------- - __vwsnf155_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf155_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) + __vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf155_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->GetText(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); @@ -1109,12 +1099,12 @@ Closures //------------------------------------------------------------------- - __vwsnf156_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf156_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) + __vwsnf155_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf155_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf156_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf155_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->GetAlt(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); @@ -1127,12 +1117,12 @@ Closures //------------------------------------------------------------------- - __vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) + __vwsnf156_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf156_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf156_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->GetSelected(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -1145,32 +1135,50 @@ Closures //------------------------------------------------------------------- - __vwsnf158_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf158_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) + __vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf158_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + void __vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const { ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->GetCommands())->ShowTab(::vl::__vwsn::This(::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueObservableList>(::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->CurrentTabPage)->GetOwnerTab())->GetPages()).Obj())->IndexOf(::vl::__vwsn::Box(__vwsnthis_0->CurrentTabPage))); } //------------------------------------------------------------------- + __vwsnf158_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::__vwsnf158_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + ::vl::presentation::templates::GuiTemplate* __vwsnf158_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + { + { + if ([&](){ auto __vwsn_temp__ = __vwsn_viewModel_; return !__vwsn_temp__.GetSharedPtr() && ::vl::__vwsn::RawPtrCast<::vl::presentation::controls::GuiTabPage>(__vwsn_temp__.GetRawPtr()) != nullptr; }()) + { + return static_cast<::vl::presentation::templates::GuiTemplate*>(new ::darkskin::TabHeaderTemplate(::vl::__vwsn::Unbox<::vl::presentation::controls::GuiTabPage*>(__vwsn_viewModel_))); + } + } + throw ::vl::Exception(::vl::WString(L"Cannot find a matched control template to create.", false)); + } + + //------------------------------------------------------------------- + __vwsnf159_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::__vwsnf159_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - ::vl::presentation::templates::GuiTemplate* __vwsnf159_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + void __vwsnf159_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->header)->GetItemSource(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::Ptr<::vl::reflection::description::IValueObservableList>>(__vwsn_value_); + if ((__vwsn_old_.Obj() == __vwsn_new_.Obj())) { - if ([&](){ auto __vwsn_temp__ = __vwsn_viewModel_; return !__vwsn_temp__.GetSharedPtr() && ::vl::__vwsn::RawPtrCast<::vl::presentation::controls::GuiTabPage>(__vwsn_temp__.GetRawPtr()) != nullptr; }()) - { - return static_cast<::vl::presentation::templates::GuiTemplate*>(new ::darkskin::TabHeaderTemplate(::vl::__vwsn::Unbox<::vl::presentation::controls::GuiTabPage*>(__vwsn_viewModel_))); - } + return; } - throw ::vl::Exception(::vl::WString(L"Cannot find a matched control template to create.", false)); + ::vl::__vwsn::This(__vwsnthis_0->header)->SetItemSource(__vwsn_new_); } //------------------------------------------------------------------- @@ -1198,15 +1206,12 @@ Closures { } - void __vwsnf160_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf160_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiItemEventArgs* arguments) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->header)->GetItemSource(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::Ptr<::vl::reflection::description::IValueObservableList>>(__vwsn_value_); - if ((__vwsn_old_.Obj() == __vwsn_new_.Obj())) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->header)->SetItemSource(__vwsn_new_); + auto flowItem = ::vl::__vwsn::This(__vwsnthis_0->header)->GetFlowItems()[::vl::__vwsn::This(arguments)->itemIndex]; + auto item = ::vl::__vwsn::Ensure(::vl::__vwsn::RawPtrCast<::darkskin::TabHeaderTemplate>(::vl::__vwsn::This(flowItem)->Children()[static_cast<::vl::vint>(0)])); + ::vl::__vwsn::This(item)->SetCommands(::vl::__vwsn::This(__vwsnthis_0->self)->GetCommands()); + ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateTabHeader(); } //------------------------------------------------------------------- @@ -1218,9 +1223,6 @@ Closures void __vwsnf161_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiItemEventArgs* arguments) const { - auto flowItem = ::vl::__vwsn::This(__vwsnthis_0->header)->GetFlowItems()[::vl::__vwsn::This(arguments)->itemIndex]; - auto item = ::vl::__vwsn::Ensure(::vl::__vwsn::RawPtrCast<::darkskin::TabHeaderTemplate>(::vl::__vwsn::This(flowItem)->Children()[static_cast<::vl::vint>(0)])); - ::vl::__vwsn::This(item)->SetCommands(::vl::__vwsn::This(__vwsnthis_0->self)->GetCommands()); ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateTabHeader(); } @@ -1231,21 +1233,23 @@ Closures { } - void __vwsnf162_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiItemEventArgs* arguments) const + void __vwsnf162_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const { ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateTabHeader(); } //------------------------------------------------------------------- - __vwsnf163_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::__vwsnf163_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabTemplateConstructor* __vwsnctorthis_0) + __vwsnf163_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__::__vwsnf163_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(::darkskin::TextListTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf163_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + ::vl::presentation::templates::GuiSelectableButtonTemplate* __vwsnf163_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateTabHeader(); + { + return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::RadioButtonTemplate()); + } } //------------------------------------------------------------------- @@ -1258,7 +1262,7 @@ Closures ::vl::presentation::templates::GuiSelectableButtonTemplate* __vwsnf164_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::RadioButtonTemplate()); + return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::CheckBoxTemplate()); } } @@ -1272,7 +1276,7 @@ Closures ::vl::presentation::templates::GuiSelectableButtonTemplate* __vwsnf165_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::CheckBoxTemplate()); + return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::ItemBackgroundTemplate()); } } @@ -1283,10 +1287,10 @@ Closures { } - ::vl::presentation::templates::GuiSelectableButtonTemplate* __vwsnf166_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + ::vl::presentation::templates::GuiScrollTemplate* __vwsnf166_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::ItemBackgroundTemplate()); + return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); } } @@ -1300,22 +1304,26 @@ Closures ::vl::presentation::templates::GuiScrollTemplate* __vwsnf167_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); + return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::HScrollTemplate()); } } //------------------------------------------------------------------- - __vwsnf168_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__::__vwsnf168_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(::darkskin::TextListTemplateConstructor* __vwsnctorthis_0) + __vwsnf168_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__::__vwsnf168_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - ::vl::presentation::templates::GuiScrollTemplate* __vwsnf168_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + void __vwsnf168_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->GetColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) { - return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::HScrollTemplate()); + return; } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->SetColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -1327,13 +1335,13 @@ Closures void __vwsnf169_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->GetColor(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetBackgroundColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->SetColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->SetBackgroundColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -1370,20 +1378,16 @@ Closures //------------------------------------------------------------------- - __vwsnf171_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__::__vwsnf171_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0) + __vwsnf171_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf171_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf171_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + ::vl::presentation::templates::GuiMenuTemplate* __vwsnf171_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetBackgroundColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) { - return; + return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->SetBackgroundColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -1393,21 +1397,7 @@ Closures { } - ::vl::presentation::templates::GuiMenuTemplate* __vwsnf172_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf173_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf173_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf173_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf172_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -1420,12 +1410,12 @@ Closures //------------------------------------------------------------------- - __vwsnf174_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf174_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf173_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf173_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf174_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf173_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -1438,12 +1428,12 @@ Closures //------------------------------------------------------------------- - __vwsnf175_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf175_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf174_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf174_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf175_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf174_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetImage(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::Ptr<::vl::presentation::INativeImage>>(__vwsn_value_); @@ -1456,12 +1446,12 @@ Closures //------------------------------------------------------------------- - __vwsnf176_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf176_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf175_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf175_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf176_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf175_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetFrameIndex(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::vint>(__vwsn_value_); @@ -1474,12 +1464,12 @@ Closures //------------------------------------------------------------------- - __vwsnf177_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf177_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf176_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf176_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf177_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf176_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetEnabled(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -1492,16 +1482,34 @@ Closures //------------------------------------------------------------------- + __vwsnf177_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf177_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + ::vl::presentation::templates::GuiMenuTemplate* __vwsnf177_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + { + { + return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); + } + } + + //------------------------------------------------------------------- + __vwsnf178_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf178_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - ::vl::presentation::templates::GuiMenuTemplate* __vwsnf178_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + void __vwsnf178_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->GetColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) { - return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); + return; } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->SetColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -1513,13 +1521,13 @@ Closures void __vwsnf179_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->GetColor(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->SetColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->SetColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -1544,24 +1552,6 @@ Closures } void __vwsnf180_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->SetColor(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf181_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf181_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf181_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetImage(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::Ptr<::vl::presentation::INativeImage>>(__vwsn_value_); @@ -1574,12 +1564,12 @@ Closures //------------------------------------------------------------------- - __vwsnf182_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf182_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf181_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf181_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf182_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf181_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetFrameIndex(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::vint>(__vwsn_value_); @@ -1592,12 +1582,12 @@ Closures //------------------------------------------------------------------- - __vwsnf183_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf183_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf182_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf182_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf183_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf182_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetEnabled(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -1610,12 +1600,12 @@ Closures //------------------------------------------------------------------- - __vwsnf184_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf184_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf183_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf183_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf184_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf183_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -1628,6 +1618,24 @@ Closures //------------------------------------------------------------------- + __vwsnf184_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf184_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf184_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->GetBackgroundColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->SetBackgroundColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + __vwsnf185_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf185_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -1646,20 +1654,16 @@ Closures //------------------------------------------------------------------- - __vwsnf186_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf186_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf186_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf186_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf186_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + ::vl::presentation::templates::GuiMenuTemplate* __vwsnf186_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->GetBackgroundColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) { - return; + return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->SetBackgroundColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -1669,10 +1673,10 @@ Closures { } - ::vl::presentation::templates::GuiMenuTemplate* __vwsnf187_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + ::vl::presentation::templates::GuiControlTemplate* __vwsnf187_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ToolstripSplitArrowTemplate()); } } @@ -1683,11 +1687,15 @@ Closures { } - ::vl::presentation::templates::GuiControlTemplate* __vwsnf188_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + void __vwsnf188_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->GetColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ToolstripSplitArrowTemplate()); + return; } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->SetColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -1699,13 +1707,13 @@ Closures void __vwsnf189_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->GetColor(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->SetColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->SetColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -1734,24 +1742,6 @@ Closures } void __vwsnf190_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->SetColor(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf191_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf191_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf191_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetImage(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::Ptr<::vl::presentation::INativeImage>>(__vwsn_value_); @@ -1764,12 +1754,12 @@ Closures //------------------------------------------------------------------- - __vwsnf192_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf192_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf191_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf191_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf192_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf191_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetFrameIndex(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::vint>(__vwsn_value_); @@ -1782,12 +1772,12 @@ Closures //------------------------------------------------------------------- - __vwsnf193_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf193_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf192_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf192_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf193_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf192_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetEnabled(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -1800,12 +1790,12 @@ Closures //------------------------------------------------------------------- - __vwsnf194_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf194_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf193_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf193_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf194_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf193_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -1818,12 +1808,12 @@ Closures //------------------------------------------------------------------- - __vwsnf195_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf195_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf194_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf194_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf195_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf194_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->buttonArrow)->GetSelected(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -1836,6 +1826,24 @@ Closures //------------------------------------------------------------------- + __vwsnf195_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf195_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf195_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBackgroundColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBackgroundColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + __vwsnf196_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf196_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -1854,20 +1862,16 @@ Closures //------------------------------------------------------------------- - __vwsnf197_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf197_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnf197_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__::__vwsnf197_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::TreeViewTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf197_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + ::vl::presentation::templates::GuiSelectableButtonTemplate* __vwsnf197_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBackgroundColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) { - return; + return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::ExpandingDecoratorTemplate()); } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBackgroundColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -1880,7 +1884,7 @@ Closures ::vl::presentation::templates::GuiSelectableButtonTemplate* __vwsnf198_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::ExpandingDecoratorTemplate()); + return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::ItemBackgroundTemplate()); } } @@ -1891,10 +1895,10 @@ Closures { } - ::vl::presentation::templates::GuiSelectableButtonTemplate* __vwsnf199_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + ::vl::presentation::templates::GuiScrollTemplate* __vwsnf199_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiSelectableButtonTemplate*>(new ::darkskin::ItemBackgroundTemplate()); + return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); } } @@ -1925,13 +1929,13 @@ Closures void __vwsnf1_DarkSkin_darkskin_BottomScrollButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBorderColor(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBackgroundColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBorderColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBackgroundColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -1942,20 +1946,6 @@ Closures } ::vl::presentation::templates::GuiScrollTemplate* __vwsnf200_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf201_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__::__vwsnf201_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::TreeViewTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiScrollTemplate* __vwsnf201_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::HScrollTemplate()); @@ -1964,12 +1954,12 @@ Closures //------------------------------------------------------------------- - __vwsnf202_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__::__vwsnf202_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollHandleTemplateConstructor* __vwsnctorthis_0) + __vwsnf201_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__::__vwsnf201_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollHandleTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf202_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf201_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -1982,6 +1972,20 @@ Closures //------------------------------------------------------------------- + __vwsnf202_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf202_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + ::vl::presentation::templates::GuiControlTemplate* __vwsnf202_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + { + { + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::TopScrollButtonTemplate()); + } + } + + //------------------------------------------------------------------- + __vwsnf203_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf203_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -1990,7 +1994,7 @@ Closures ::vl::presentation::templates::GuiControlTemplate* __vwsnf203_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::TopScrollButtonTemplate()); + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::BottomScrollButtonTemplate()); } } @@ -2004,7 +2008,7 @@ Closures ::vl::presentation::templates::GuiControlTemplate* __vwsnf204_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::BottomScrollButtonTemplate()); + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::VScrollHandleTemplate()); } } @@ -2015,11 +2019,15 @@ Closures { } - ::vl::presentation::templates::GuiControlTemplate* __vwsnf205_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + void __vwsnf205_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetHeightPageSize(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::VScrollHandleTemplate()); + return; } + ::vl::__vwsn::This(__vwsnthis_0->handle)->SetHeightPageSize(__vwsn_new_); } //------------------------------------------------------------------- @@ -2029,53 +2037,60 @@ Closures { } - void __vwsnf206_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + void __vwsnf206_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->GetCommands())->SmallDecrease(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetHeightRatio(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->handle)->SetHeightRatio(__vwsn_new_); } //------------------------------------------------------------------- - __vwsnf207_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf207_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) + __vwsnf207_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf207_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf207_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + ::vl::presentation::templates::GuiControlTemplate* __vwsnf207_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->GetCommands())->SmallIncrease(); + { + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ButtonTemplate()); + } } //------------------------------------------------------------------- - __vwsnf208_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf208_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) + __vwsnf208_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf208_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf208_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf208_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7)->GetAlignmentToParent(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetAlignmentToParent(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Margin>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7)->SetAlignmentToParent(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->handle)->SetAlignmentToParent(__vwsn_new_); } //------------------------------------------------------------------- - __vwsnf209_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf209_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) + __vwsnf209_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf209_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf209_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const + ::vl::presentation::templates::GuiWindowTemplate* __vwsnf209_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - if (::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->handleContainer)->GetRelatedControl())->GetVisuallyEnabled()) { - ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->GetCommands())->BigDecrease(); + return static_cast<::vl::presentation::templates::GuiWindowTemplate*>(new ::darkskin::TooltipTemplate()); } } @@ -2099,128 +2114,12 @@ Closures //------------------------------------------------------------------- - __vwsnf210_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf210_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) + __vwsnf210_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf210_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf210_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8)->GetAlignmentToParent(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Margin>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8)->SetAlignmentToParent(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf211_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf211_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf211_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const - { - if (::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->handleContainer)->GetRelatedControl())->GetVisuallyEnabled()) - { - ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->GetCommands())->BigIncrease(); - } - } - - //------------------------------------------------------------------- - - __vwsnf212_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf212_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf212_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetHeightPageSize(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->handle)->SetHeightPageSize(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf213_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf213_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf213_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetHeightRatio(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->handle)->SetHeightRatio(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf214_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf214_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf214_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const - { - if (::vl::__vwsn::This(__vwsnthis_0->self)->GetVisuallyEnabled()) - { - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle = true); - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingStartLocation = [&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = ::vl::__vwsn::This(arguments)->x; __vwsn_temp__.y = ::vl::__vwsn::This(arguments)->y; return __vwsn_temp__; }()); - } - } - - //------------------------------------------------------------------- - - __vwsnf215_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf215_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf215_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const - { - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle = false); - } - - //------------------------------------------------------------------- - - __vwsnf216_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf216_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf216_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const - { - if (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle) - { - auto bounds = ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->handle)->GetParent())->GetBounds(); - auto totalPixels = (bounds.y2 - bounds.y1); - auto currentOffset = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetBounds().y1; - auto newOffset = (currentOffset + (::vl::__vwsn::This(arguments)->y - ::vl::__vwsn::This(__vwsnthis_0->self)->draggingStartLocation.y)); - ::ScrollTemplateScript::SetScroll(totalPixels, newOffset, static_cast<::vl::presentation::templates::GuiScrollTemplate*>(__vwsnthis_0->self)); - } - } - - //------------------------------------------------------------------- - - __vwsnf217_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf217_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiControlTemplate* __vwsnf217_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + ::vl::presentation::templates::GuiControlTemplate* __vwsnf210_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ButtonTemplate()); @@ -2229,40 +2128,70 @@ Closures //------------------------------------------------------------------- - __vwsnf218_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf218_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0) + __vwsnf211_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf211_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf218_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + ::vl::presentation::templates::GuiControlTemplate* __vwsnf211_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetAlignmentToParent(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Margin>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) { - return; + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ButtonTemplate()); } - ::vl::__vwsn::This(__vwsnthis_0->handle)->SetAlignmentToParent(__vwsn_new_); } //------------------------------------------------------------------- - __vwsnf219_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf219_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0) + __vwsnf212_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf212_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf219_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const + ::vl::presentation::templates::GuiControlTemplate* __vwsnf212_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - if (::vl::__vwsn::This(__vwsnthis_0->self)->GetVisuallyEnabled()) { - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle = true); - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingStartLocation = [&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = ::vl::__vwsn::This(arguments)->x; __vwsn_temp__.y = ::vl::__vwsn::This(arguments)->y; return __vwsn_temp__; }()); + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ButtonTemplate()); } } //------------------------------------------------------------------- + __vwsnf213_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf213_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf213_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_16)->GetText(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_16)->SetText(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf214_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf214_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf214_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_23.Obj())->GetText(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_23.Obj())->SetText(__vwsn_new_); + } + + //------------------------------------------------------------------- + __vwsnf21_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf21_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::ComboBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -2281,129 +2210,6 @@ Closures //------------------------------------------------------------------- - __vwsnf220_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf220_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf220_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const - { - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle = false); - } - - //------------------------------------------------------------------- - - __vwsnf221_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf221_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf221_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const - { - if (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle) - { - auto bounds = ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->handle)->GetParent())->GetBounds(); - auto totalPixels = (bounds.y2 - bounds.y1); - auto currentOffset = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetBounds().y1; - auto newOffset = (currentOffset + (::vl::__vwsn::This(arguments)->y - ::vl::__vwsn::This(__vwsnthis_0->self)->draggingStartLocation.y)); - ::ScrollTemplateScript::SetScroll(totalPixels, newOffset, static_cast<::vl::presentation::templates::GuiScrollTemplate*>(__vwsnthis_0->self)); - } - } - - //------------------------------------------------------------------- - - __vwsnf222_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf222_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiWindowTemplate* __vwsnf222_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiWindowTemplate*>(new ::darkskin::TooltipTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf223_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf223_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiControlTemplate* __vwsnf223_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ButtonTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf224_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf224_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiControlTemplate* __vwsnf224_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ButtonTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf225_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf225_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiControlTemplate* __vwsnf225_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ButtonTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf226_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf226_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf226_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_16)->GetText(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_16)->SetText(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf227_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::__vwsnf227_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf227_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_23.Obj())->GetText(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_23.Obj())->SetText(__vwsn_new_); - } - - //------------------------------------------------------------------- - __vwsnf22_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf22_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::ComboBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -2447,13 +2253,13 @@ Closures void __vwsnf24_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->GetBorderColor(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->GetBackgroundColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->SetBorderColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->SetBackgroundColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -2465,13 +2271,13 @@ Closures void __vwsnf25_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->GetBackgroundColor(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->GetBorderColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->SetBackgroundColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->SetBorderColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -2539,13 +2345,13 @@ Closures void __vwsnf2_DarkSkin_darkskin_BottomScrollButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBackgroundColor(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBorderColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBackgroundColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBorderColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -3094,84 +2900,92 @@ Closures //------------------------------------------------------------------- - __vwsnf65_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__::__vwsnf65_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DocumentViewerTemplateConstructor* __vwsnctorthis_0) + __vwsnf65_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__::__vwsnf65_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - ::vl::presentation::templates::GuiScrollTemplate* __vwsnf65_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + void __vwsnf65_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - { - return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf66_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__::__vwsnf66_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DocumentViewerTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiScrollTemplate* __vwsnf66_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::HScrollTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf67_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf67_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf67_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetBorderColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->look)->GetFont(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->SetBorderColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->look)->SetFont(__vwsn_new_); } //------------------------------------------------------------------- - __vwsnf68_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf68_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + __vwsnf66_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__::__vwsnf66_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf68_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf66_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetBackgroundColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->look)->GetDate(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::DateTime>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->SetBackgroundColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->look)->SetDate(__vwsn_new_); } //------------------------------------------------------------------- - __vwsnf69_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf69_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + __vwsnf67_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__::__vwsnf67_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf69_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf67_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2)->GetVisible(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->look)->GetDateLocale(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::Locale>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2)->SetVisible(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->look)->SetDateLocale(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf68_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__::__vwsnf68_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf68_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->look)->GetCommands(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::controls::IDatePickerCommandExecutor*>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->look)->SetCommands(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf69_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__::__vwsnf69_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf69_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->self)->GetDate(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::DateTime>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->self)->SetDate(__vwsn_new_); } //------------------------------------------------------------------- @@ -3194,30 +3008,94 @@ Closures //------------------------------------------------------------------- - __vwsnf70_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf70_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + __vwsnf70_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__::__vwsnf70_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DocumentViewerTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf70_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + ::vl::presentation::templates::GuiScrollTemplate* __vwsnf70_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_5.Obj())->GetBorderColor(); + { + return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::VScrollTemplate()); + } + } + + //------------------------------------------------------------------- + + __vwsnf71_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__::__vwsnf71_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DocumentViewerTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + ::vl::presentation::templates::GuiScrollTemplate* __vwsnf71_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + { + { + return static_cast<::vl::presentation::templates::GuiScrollTemplate*>(new ::darkskin::HScrollTemplate()); + } + } + + //------------------------------------------------------------------- + + __vwsnf72_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf72_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf72_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetBackgroundColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_5.Obj())->SetBorderColor(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->SetBackgroundColor(__vwsn_new_); } //------------------------------------------------------------------- - __vwsnf71_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf71_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + __vwsnf73_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf73_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf71_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf73_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->GetBorderColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_3.Obj())->SetBorderColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf74_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf74_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf74_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2)->GetVisible(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2)->SetVisible(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf75_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf75_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf75_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_5.Obj())->GetBackgroundColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -3230,12 +3108,30 @@ Closures //------------------------------------------------------------------- - __vwsnf72_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf72_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + __vwsnf76_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf76_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf72_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf76_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_5.Obj())->GetBorderColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_5.Obj())->SetBorderColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf77_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::__vwsnf77_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf77_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4)->GetVisible(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -3248,12 +3144,12 @@ Closures //------------------------------------------------------------------- - __vwsnf73_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf73_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) + __vwsnf78_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf78_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf73_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf78_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1)->GetAlignmentToParent(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Margin>(__vwsn_value_); @@ -3266,12 +3162,12 @@ Closures //------------------------------------------------------------------- - __vwsnf74_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf74_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) + __vwsnf79_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf79_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf74_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf79_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_5.Obj())->GetText(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); @@ -3284,84 +3180,6 @@ Closures //------------------------------------------------------------------- - __vwsnf75_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf75_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf75_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_5.Obj())->GetFont(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_5.Obj())->SetFont(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf76_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__::__vwsnf76_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollHandleTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf76_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->GetColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->SetColor(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf77_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf77_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiControlTemplate* __vwsnf77_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::LeftScrollButtonTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf78_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf78_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiControlTemplate* __vwsnf78_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::RightScrollButtonTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf79_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf79_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiControlTemplate* __vwsnf79_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::HScrollHandleTemplate()); - } - } - - //------------------------------------------------------------------- - __vwsnf7_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf7_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -3380,26 +3198,38 @@ Closures //------------------------------------------------------------------- - __vwsnf80_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf80_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) + __vwsnf80_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf80_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf80_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + void __vwsnf80_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->GetCommands())->SmallDecrease(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_5.Obj())->GetFont(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_5.Obj())->SetFont(__vwsn_new_); } //------------------------------------------------------------------- - __vwsnf81_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf81_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) + __vwsnf81_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__::__vwsnf81_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollHandleTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf81_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + void __vwsnf81_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->GetCommands())->SmallIncrease(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->GetColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->SetColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -3409,15 +3239,11 @@ Closures { } - void __vwsnf82_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + ::vl::presentation::templates::GuiControlTemplate* __vwsnf82_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7)->GetAlignmentToParent(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Margin>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) { - return; + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::LeftScrollButtonTemplate()); } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_7)->SetAlignmentToParent(__vwsn_new_); } //------------------------------------------------------------------- @@ -3427,11 +3253,10 @@ Closures { } - void __vwsnf83_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const + ::vl::presentation::templates::GuiControlTemplate* __vwsnf83_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - if (::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->handleContainer)->GetRelatedControl())->GetVisuallyEnabled()) { - ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->GetCommands())->BigDecrease(); + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::RightScrollButtonTemplate()); } } @@ -3442,15 +3267,11 @@ Closures { } - void __vwsnf84_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + ::vl::presentation::templates::GuiControlTemplate* __vwsnf84_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8)->GetAlignmentToParent(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Margin>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) { - return; + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::HScrollHandleTemplate()); } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8)->SetAlignmentToParent(__vwsn_new_); } //------------------------------------------------------------------- @@ -3460,22 +3281,7 @@ Closures { } - void __vwsnf85_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const - { - if (::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->handleContainer)->GetRelatedControl())->GetVisuallyEnabled()) - { - ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->GetCommands())->BigIncrease(); - } - } - - //------------------------------------------------------------------- - - __vwsnf86_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf86_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf86_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf85_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetWidthPageSize(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -3488,12 +3294,12 @@ Closures //------------------------------------------------------------------- - __vwsnf87_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf87_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) + __vwsnf86_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf86_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf87_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf86_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetWidthRatio(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -3506,30 +3312,52 @@ Closures //------------------------------------------------------------------- - __vwsnf88_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf88_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) + __vwsnf87_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf87_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf88_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const + ::vl::presentation::templates::GuiControlTemplate* __vwsnf87_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { - if (::vl::__vwsn::This(__vwsnthis_0->self)->GetVisuallyEnabled()) { - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle = true); - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingStartLocation = [&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = ::vl::__vwsn::This(arguments)->x; __vwsn_temp__.y = ::vl::__vwsn::This(arguments)->y; return __vwsn_temp__; }()); + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ButtonTemplate()); } } //------------------------------------------------------------------- - __vwsnf89_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf89_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) + __vwsnf88_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf88_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf89_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const + void __vwsnf88_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle = false); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetAlignmentToParent(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Margin>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->handle)->SetAlignmentToParent(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf89_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__::__vwsnf89_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__(::darkskin::ItemBackgroundTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf89_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->SetColor(__vwsn_new_); } //------------------------------------------------------------------- @@ -3552,128 +3380,12 @@ Closures //------------------------------------------------------------------- - __vwsnf90_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::__vwsnf90_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) + __vwsnf90_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::__vwsnf90_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf90_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const - { - if (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle) - { - auto bounds = ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->handle)->GetParent())->GetBounds(); - auto totalPixels = (bounds.x2 - bounds.x1); - auto currentOffset = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetBounds().x1; - auto newOffset = (currentOffset + (::vl::__vwsn::This(arguments)->x - ::vl::__vwsn::This(__vwsnthis_0->self)->draggingStartLocation.x)); - ::ScrollTemplateScript::SetScroll(totalPixels, newOffset, static_cast<::vl::presentation::templates::GuiScrollTemplate*>(__vwsnthis_0->self)); - } - } - - //------------------------------------------------------------------- - - __vwsnf91_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf91_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiControlTemplate* __vwsnf91_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ButtonTemplate()); - } - } - - //------------------------------------------------------------------- - - __vwsnf92_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf92_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf92_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetAlignmentToParent(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Margin>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->handle)->SetAlignmentToParent(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf93_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf93_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf93_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const - { - if (::vl::__vwsn::This(__vwsnthis_0->self)->GetVisuallyEnabled()) - { - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle = true); - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingStartLocation = [&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = ::vl::__vwsn::This(arguments)->x; __vwsn_temp__.y = ::vl::__vwsn::This(arguments)->y; return __vwsn_temp__; }()); - } - } - - //------------------------------------------------------------------- - - __vwsnf94_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf94_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf94_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const - { - (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle = false); - } - - //------------------------------------------------------------------- - - __vwsnf95_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::__vwsnf95_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf95_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const - { - if (::vl::__vwsn::This(__vwsnthis_0->self)->draggingHandle) - { - auto bounds = ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->handle)->GetParent())->GetBounds(); - auto totalPixels = (bounds.x2 - bounds.x1); - auto currentOffset = ::vl::__vwsn::This(__vwsnthis_0->handle)->GetBounds().x1; - auto newOffset = (currentOffset + (::vl::__vwsn::This(arguments)->x - ::vl::__vwsn::This(__vwsnthis_0->self)->draggingStartLocation.x)); - ::ScrollTemplateScript::SetScroll(totalPixels, newOffset, static_cast<::vl::presentation::templates::GuiScrollTemplate*>(__vwsnthis_0->self)); - } - } - - //------------------------------------------------------------------- - - __vwsnf96_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__::__vwsnf96_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__(::darkskin::ItemBackgroundTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf96_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->SetColor(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf97_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::__vwsnf97_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf97_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf90_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetText(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); @@ -3686,12 +3398,12 @@ Closures //------------------------------------------------------------------- - __vwsnf98_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::__vwsnf98_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) + __vwsnf91_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::__vwsnf91_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf98_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf91_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetColor(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); @@ -3704,12 +3416,12 @@ Closures //------------------------------------------------------------------- - __vwsnf99_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::__vwsnf99_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) + __vwsnf92_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::__vwsnf92_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf99_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf92_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetFont(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); @@ -3722,6 +3434,124 @@ Closures //------------------------------------------------------------------- + __vwsnf93_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf93_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf93_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBackgroundColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBackgroundColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf94_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__::__vwsnf94_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf94_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->GetBorderColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_2.Obj())->SetBorderColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf95_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf95_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + ::vl::presentation::templates::GuiMenuTemplate* __vwsnf95_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + { + { + return static_cast<::vl::presentation::templates::GuiMenuTemplate*>(new ::darkskin::ToolstripMenuTemplate()); + } + } + + //------------------------------------------------------------------- + + __vwsnf96_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf96_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + ::vl::presentation::templates::GuiControlTemplate* __vwsnf96_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + { + { + return static_cast<::vl::presentation::templates::GuiControlTemplate*>(new ::darkskin::ToolstripSplitArrowTemplate()); + } + } + + //------------------------------------------------------------------- + + __vwsnf97_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf97_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf97_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->GetColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0.Obj())->SetColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf98_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf98_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf98_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->GetBackgroundColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->SetBackgroundColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf99_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::__vwsnf99_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf99_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->GetBorderColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_8.Obj())->SetBorderColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + __vwsnf9_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__::__vwsnf9_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::CheckBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -3740,126 +3570,12 @@ Closures //------------------------------------------------------------------- - __vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetFrameIndex(); } catch(...){ return static_cast<::vl::vint>(0); } }(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetVisuallyEnabled(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); @@ -3867,28 +3583,28 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSelected()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { @@ -3896,15 +3612,15 @@ Closures (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; } - bool __vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -3914,17 +3630,17 @@ Closures return false; } - bool __vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); @@ -3935,210 +3651,48 @@ Closures //------------------------------------------------------------------- - __vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - return true; - } - return false; - } - - bool __vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - return true; - } - return false; - } - - bool __vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetSelected()) ? ::vl::WString(L"#00000000", false) : ::vl::WString(L"#007ACC", false)); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4148,15 +3702,15 @@ Closures return false; } - bool __vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -4166,12 +3720,12 @@ Closures //------------------------------------------------------------------- - __vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); @@ -4179,28 +3733,28 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { @@ -4208,15 +3762,15 @@ Closures (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; } - bool __vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4226,7 +3780,7 @@ Closures return false; } - bool __vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -4234,9 +3788,9 @@ Closures ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); @@ -4247,39 +3801,39 @@ Closures //------------------------------------------------------------------- - __vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetImage(); } catch(...){ return ::vl::Ptr<::vl::presentation::INativeImage>(); } }(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4289,13 +3843,13 @@ Closures return false; } - bool __vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -4304,39 +3858,39 @@ Closures //------------------------------------------------------------------- - __vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetFrameIndex(); } catch(...){ return static_cast<::vl::vint>(0); } }(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4346,13 +3900,13 @@ Closures return false; } - bool __vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -4361,39 +3915,39 @@ Closures //------------------------------------------------------------------- - __vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetVisuallyEnabled(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4403,13 +3957,277 @@ Closures return false; } - bool __vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetSelected()) ? ::vl::WString(L"#00000000", false) : ::vl::WString(L"#007ACC", false)); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + return true; + } + return false; + } + + bool __vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetImage(); } catch(...){ return ::vl::Ptr<::vl::presentation::INativeImage>(); } }(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetFrameIndex(); } catch(...){ return static_cast<::vl::vint>(0); } }(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -4487,7 +4305,307 @@ Closures //------------------------------------------------------------------- - __vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetVisuallyEnabled(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + return true; + } + return false; + } + + bool __vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + return true; + } + return false; + } + + bool __vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + return true; + } + return false; + } + + bool __vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); @@ -4498,37 +4616,37 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#54545C", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetSelected()) ? ::vl::WString(L"#00000000", false) : ::vl::WString(L"#007ACC", false)); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4538,13 +4656,13 @@ Closures return false; } - bool __vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, __vwsn_bind_handler_1_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); @@ -4556,39 +4674,57 @@ Closures //------------------------------------------------------------------- - __vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSubMenuOpening(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + void __vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; } - bool __vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4598,12 +4734,75 @@ Closures return false; } - bool __vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuOpeningChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetImage(); } catch(...){ return ::vl::Ptr<::vl::presentation::INativeImage>(); } }(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -4613,48 +4812,39 @@ Closures //------------------------------------------------------------------- - __vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetFrameIndex(); } catch(...){ return static_cast<::vl::vint>(0); } }(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4664,15 +4854,138 @@ Closures return false; } - bool __vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetVisuallyEnabled(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#54545C", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -4682,549 +4995,6 @@ Closures //------------------------------------------------------------------- - __vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollHandleTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollHandleTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollHandleTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#3D3D42", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#9E9E9E", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#EFEBEF", false) : ::vl::WString(L"#686868", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollHandleTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollHandleTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::vl::presentation::compositions::GuiPartialViewComposition*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = ((::vl::__vwsn::This(__vwsn_bind_cache_0)->GetBounds().y2 - ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetBounds().y1) - ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetBounds().y1); return __vwsn_temp__; }(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->handleContainer); - (__vwsn_bind_cache_1 = __vwsnthis_0->handleContainer); - (__vwsn_bind_cache_2 = __vwsnthis_0->handle); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, ::vl::Func(this, &__vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, ::vl::Func(this, &__vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->BoundsChanged, ::vl::Func(this, &__vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - return true; - } - return false; - } - - bool __vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->BoundsChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::vl::presentation::compositions::GuiPartialViewComposition*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiPartialViewComposition*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetBounds().y2; __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->handle); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, ::vl::Func(this, &__vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiPartialViewComposition*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = (static_cast(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetPageSize()) / static_cast(::vl::__vwsn::This(__vwsn_bind_cache_1)->GetTotalSize())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PageSizeChanged, ::vl::Func(this, &__vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, ::vl::Func(this, &__vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PageSizeChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = (static_cast(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetPosition()) / static_cast(::vl::__vwsn::This(__vwsn_bind_cache_1)->GetTotalSize())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PositionChanged, ::vl::Func(this, &__vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, ::vl::Func(this, &__vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PositionChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::VTrackerTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::VTrackerTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - this->__vwsn_bind_cache_3 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - this->__vwsn_bind_cache_4 = static_cast<::darkskin::VTrackerTemplate*>(nullptr); - this->__vwsn_bind_cache_5 = static_cast<::darkskin::VTrackerTemplate*>(nullptr); - this->__vwsn_bind_cache_6 = static_cast<::darkskin::VTrackerTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_3_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_4_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_5_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_6_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = [&](auto height, auto max){ return ((max == static_cast<::vl::vint>(0)) ? static_cast<::vl::vint>(0) : ((height * ::vl::__vwsn::This(__vwsn_bind_cache_6)->GetPosition()) / max)); }(((::vl::__vwsn::This(__vwsn_bind_cache_0)->GetBounds().y2 - ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetBounds().y1) - (::vl::__vwsn::This(__vwsn_bind_cache_2)->GetBounds().y2 - ::vl::__vwsn::This(__vwsn_bind_cache_3)->GetBounds().y1)), (::vl::__vwsn::This(__vwsn_bind_cache_4)->GetTotalSize() - ::vl::__vwsn::This(__vwsn_bind_cache_5)->GetPageSize())); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = (- static_cast<::vl::vint>(1)); return __vwsn_temp__; }(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_3_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_4_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_5_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_6_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->handle); - (__vwsn_bind_cache_3 = __vwsnthis_0->handle); - (__vwsn_bind_cache_4 = __vwsnthis_0->self); - (__vwsn_bind_cache_5 = __vwsnthis_0->self); - (__vwsn_bind_cache_6 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, ::vl::Func(this, &__vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, ::vl::Func(this, &__vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->BoundsChanged, ::vl::Func(this, &__vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - (__vwsn_bind_handler_3_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_3)->BoundsChanged, ::vl::Func(this, &__vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_3_0))); - (__vwsn_bind_handler_4_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_4)->TotalSizeChanged, ::vl::Func(this, &__vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_4_0))); - (__vwsn_bind_handler_5_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_5)->PageSizeChanged, ::vl::Func(this, &__vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_5_0))); - (__vwsn_bind_handler_6_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_6)->PositionChanged, ::vl::Func(this, &__vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_6_0))); - return true; - } - return false; - } - - bool __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->BoundsChanged, __vwsn_bind_handler_2_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_3)->BoundsChanged, __vwsn_bind_handler_3_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_4)->TotalSizeChanged, __vwsn_bind_handler_4_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_5)->PageSizeChanged, __vwsn_bind_handler_5_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_6)->PositionChanged, __vwsn_bind_handler_6_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::VTrackerTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::VTrackerTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); - (__vwsn_bind_cache_3 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); - (__vwsn_bind_cache_4 = static_cast<::darkskin::VTrackerTemplate*>(nullptr)); - (__vwsn_bind_cache_5 = static_cast<::darkskin::VTrackerTemplate*>(nullptr)); - (__vwsn_bind_cache_6 = static_cast<::darkskin::VTrackerTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_3_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_4_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_5_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_6_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - __vwsnc11_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc11_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::CheckBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -5282,39 +5052,39 @@ Closures //------------------------------------------------------------------- - __vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) + __vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::WindowTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = (::vl::__vwsn::This(__vwsn_bind_cache_0)->GetMaximized() ? ::vl::WString(L" 1 ", false) : ::vl::WString(L" 2 ", false)); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSubMenuOpening(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->MaximizedChanged, ::vl::Func(this, &__vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -5324,7 +5094,490 @@ Closures return false; } - bool __vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuOpeningChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::TopScrollButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollHandleTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollHandleTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollHandleTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#3D3D42", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#9E9E9E", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#EFEBEF", false) : ::vl::WString(L"#686868", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollHandleTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollHandleTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = (static_cast(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetPageSize()) / static_cast(::vl::__vwsn::This(__vwsn_bind_cache_1)->GetTotalSize())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PageSizeChanged, ::vl::Func(this, &__vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, ::vl::Func(this, &__vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PageSizeChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = (static_cast(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetPosition()) / static_cast(::vl::__vwsn::This(__vwsn_bind_cache_1)->GetTotalSize())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PositionChanged, ::vl::Func(this, &__vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, ::vl::Func(this, &__vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PositionChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::VScrollTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::VScrollTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::VTrackerTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::VTrackerTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::VTrackerTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = ::vl::__vwsn::This(__vwsnthis_0->behavior)->GetVerticalTrackerHandlerPosition(__vwsnthis_0->handle, ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetTotalSize(), ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetPageSize(), ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetPosition()); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = (- static_cast<::vl::vint>(1)); return __vwsn_temp__; }(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TotalSizeChanged, ::vl::Func(this, &__vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->PageSizeChanged, ::vl::Func(this, &__vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->PositionChanged, ::vl::Func(this, &__vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + return true; + } + return false; + } + + bool __vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TotalSizeChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->PageSizeChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->PositionChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::VTrackerTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::VTrackerTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::VTrackerTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::WindowTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = (::vl::__vwsn::This(__vwsn_bind_cache_0)->GetMaximized() ? ::vl::WString(L" 1 ", false) : ::vl::WString(L" 2 ", false)); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->MaximizedChanged, ::vl::Func(this, &__vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -5339,7 +5592,7 @@ Closures //------------------------------------------------------------------- - __vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) + __vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::WindowTemplate*>(nullptr); @@ -5348,30 +5601,30 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -5381,7 +5634,7 @@ Closures return false; } - bool __vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -6134,7 +6387,7 @@ Closures void __vwsnc22_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#999999", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#2D2D30", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#3F3F46", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#3F3F46", false) : ::vl::WString(L"#434346", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -6215,7 +6468,7 @@ Closures void __vwsnc23_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#2D2D30", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#3F3F46", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#3F3F46", false) : ::vl::WString(L"#434346", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#999999", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -6281,48 +6534,39 @@ Closures //------------------------------------------------------------------- - __vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + __vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::DatePickerTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#0A75B9", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#0A75B9", false) : ::vl::WString(L"#F1F1F1", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -6332,154 +6576,13 @@ Closures return false; } - bool __vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetSelected()) ? ::vl::WString(L"#00000000", false) : ((! ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#0A75B9", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#0A75B9", false) : ::vl::WString(L"#F1F1F1", false))))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - return true; - } - return false; - } - - bool __vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->VisuallyEnabledChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = (! ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelected()); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, ::vl::Func(this, &__vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::DatePickerTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -6488,48 +6591,39 @@ Closures //------------------------------------------------------------------- - __vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + __vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::DatePickerTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#0A75B9", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#0A75B9", false) : ::vl::WString(L"#F1F1F1", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetDate(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->DateChanged, ::vl::Func(this, &__vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -6539,17 +6633,14 @@ Closures return false; } - bool __vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->DateChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::DatePickerTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } return false; @@ -6557,57 +6648,39 @@ Closures //------------------------------------------------------------------- - __vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + __vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::DatePickerTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetSelected()) ? ::vl::WString(L"#00000000", false) : ((! ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#0A75B9", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#0A75B9", false) : ::vl::WString(L"#F1F1F1", false))))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetDateLocale(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->DateLocaleChanged, ::vl::Func(this, &__vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -6617,20 +6690,128 @@ Closures return false; } - bool __vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->VisuallyEnabledChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->DateLocaleChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::DatePickerTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::DatePickerTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCommands(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CommandsChanged, ::vl::Func(this, &__vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CommandsChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::DatePickerTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::templates::GuiCommonDatePickerLook*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetDate(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->look); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->DateChanged, ::vl::Func(this, &__vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->DateChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::vl::presentation::templates::GuiCommonDatePickerLook*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } return false; @@ -6642,14 +6823,18 @@ Closures :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } void __vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelected(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetSelected()) ? ::vl::WString(L"#00000000", false) : ((! ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#0A75B9", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#0A75B9", false) : ::vl::WString(L"#F1F1F1", false))))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -6658,13 +6843,27 @@ Closures this->__vwsn_bind_activator_(); } + void __vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + bool __vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, ::vl::Func(this, &__vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; @@ -6685,9 +6884,15 @@ Closures if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->VisuallyEnabledChanged, __vwsn_bind_handler_2_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } return false; @@ -6764,39 +6969,48 @@ Closures //------------------------------------------------------------------- - __vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) + __vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = (::vl::__vwsn::This(__vwsn_bind_cache_0)->GetBounds().y2 / static_cast<::vl::vint>(2)); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#0A75B9", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#0A75B9", false) : ::vl::WString(L"#F1F1F1", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + void __vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->titleBounds); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, ::vl::Func(this, &__vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -6806,7 +7020,331 @@ Closures return false; } - bool __vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = (! ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelected()); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, ::vl::Func(this, &__vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetSelected()) ? ::vl::WString(L"#00000000", false) : ((! ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#0A75B9", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#0A75B9", false) : ::vl::WString(L"#F1F1F1", false))))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + return true; + } + return false; + } + + bool __vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->VisuallyEnabledChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#0A75B9", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#0A75B9", false) : ::vl::WString(L"#F1F1F1", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelected(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, ::vl::Func(this, &__vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ExpandingDecoratorTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = (::vl::__vwsn::This(__vwsn_bind_cache_0)->GetBounds().y2 / static_cast<::vl::vint>(2)); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->titleBounds); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, ::vl::Func(this, &__vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -6821,7 +7359,7 @@ Closures //------------------------------------------------------------------- - __vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) + __vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::GroupBoxTemplate*>(nullptr); @@ -6830,30 +7368,30 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -6863,7 +7401,7 @@ Closures return false; } - bool __vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -6878,7 +7416,7 @@ Closures //------------------------------------------------------------------- - __vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) + __vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::GroupBoxTemplate*>(nullptr); @@ -6887,30 +7425,30 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -6920,7 +7458,7 @@ Closures return false; } - bool __vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -6935,7 +7473,7 @@ Closures //------------------------------------------------------------------- - __vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollHandleTemplateConstructor* __vwsnctorthis_0) + __vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollHandleTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::HScrollHandleTemplate*>(nullptr); @@ -6946,37 +7484,37 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#3D3D42", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#9E9E9E", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#EFEBEF", false) : ::vl::WString(L"#686868", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -6986,7 +7524,7 @@ Closures return false; } - bool __vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -7004,145 +7542,7 @@ Closures //------------------------------------------------------------------- - __vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::vl::presentation::compositions::GuiPartialViewComposition*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = ((::vl::__vwsn::This(__vwsn_bind_cache_0)->GetBounds().x2 - ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetBounds().x1) - ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetBounds().x1); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->handleContainer); - (__vwsn_bind_cache_1 = __vwsnthis_0->handleContainer); - (__vwsn_bind_cache_2 = __vwsnthis_0->handle); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, ::vl::Func(this, &__vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, ::vl::Func(this, &__vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->BoundsChanged, ::vl::Func(this, &__vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - return true; - } - return false; - } - - bool __vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->BoundsChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::vl::presentation::compositions::GuiPartialViewComposition*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiPartialViewComposition*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetBounds().x2; __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->handle); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, ::vl::Func(this, &__vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiPartialViewComposition*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) + __vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::HScrollTemplate*>(nullptr); @@ -7153,37 +7553,37 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = (static_cast(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetPageSize()) / static_cast(::vl::__vwsn::This(__vwsn_bind_cache_1)->GetTotalSize())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PageSizeChanged, ::vl::Func(this, &__vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, ::vl::Func(this, &__vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PageSizeChanged, ::vl::Func(this, &__vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, ::vl::Func(this, &__vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -7193,7 +7593,7 @@ Closures return false; } - bool __vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -7211,285 +7611,6 @@ Closures //------------------------------------------------------------------- - __vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::HScrollTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::HScrollTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = (static_cast(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetPosition()) / static_cast(::vl::__vwsn::This(__vwsn_bind_cache_1)->GetTotalSize())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PositionChanged, ::vl::Func(this, &__vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, ::vl::Func(this, &__vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PositionChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::HScrollTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::HScrollTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::HTrackerTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::HTrackerTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - this->__vwsn_bind_cache_3 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - this->__vwsn_bind_cache_4 = static_cast<::darkskin::HTrackerTemplate*>(nullptr); - this->__vwsn_bind_cache_5 = static_cast<::darkskin::HTrackerTemplate*>(nullptr); - this->__vwsn_bind_cache_6 = static_cast<::darkskin::HTrackerTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_3_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_4_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_5_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_6_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = [&](auto width, auto max){ return ((max == static_cast<::vl::vint>(0)) ? static_cast<::vl::vint>(0) : ((width * ::vl::__vwsn::This(__vwsn_bind_cache_6)->GetPosition()) / max)); }(((::vl::__vwsn::This(__vwsn_bind_cache_0)->GetBounds().x2 - ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetBounds().x1) - (::vl::__vwsn::This(__vwsn_bind_cache_2)->GetBounds().x2 - ::vl::__vwsn::This(__vwsn_bind_cache_3)->GetBounds().x1)), (::vl::__vwsn::This(__vwsn_bind_cache_4)->GetTotalSize() - ::vl::__vwsn::This(__vwsn_bind_cache_5)->GetPageSize())); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = (- static_cast<::vl::vint>(1)); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_3_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_4_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_5_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_6_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->handle); - (__vwsn_bind_cache_3 = __vwsnthis_0->handle); - (__vwsn_bind_cache_4 = __vwsnthis_0->self); - (__vwsn_bind_cache_5 = __vwsnthis_0->self); - (__vwsn_bind_cache_6 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, ::vl::Func(this, &__vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, ::vl::Func(this, &__vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->BoundsChanged, ::vl::Func(this, &__vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - (__vwsn_bind_handler_3_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_3)->BoundsChanged, ::vl::Func(this, &__vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_3_0))); - (__vwsn_bind_handler_4_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_4)->TotalSizeChanged, ::vl::Func(this, &__vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_4_0))); - (__vwsn_bind_handler_5_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_5)->PageSizeChanged, ::vl::Func(this, &__vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_5_0))); - (__vwsn_bind_handler_6_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_6)->PositionChanged, ::vl::Func(this, &__vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_6_0))); - return true; - } - return false; - } - - bool __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->BoundsChanged, __vwsn_bind_handler_2_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_3)->BoundsChanged, __vwsn_bind_handler_3_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_4)->TotalSizeChanged, __vwsn_bind_handler_4_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_5)->PageSizeChanged, __vwsn_bind_handler_5_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_6)->PositionChanged, __vwsn_bind_handler_6_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::HTrackerTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::HTrackerTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); - (__vwsn_bind_cache_3 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); - (__vwsn_bind_cache_4 = static_cast<::darkskin::HTrackerTemplate*>(nullptr)); - (__vwsn_bind_cache_5 = static_cast<::darkskin::HTrackerTemplate*>(nullptr)); - (__vwsn_bind_cache_6 = static_cast<::darkskin::HTrackerTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_3_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_4_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_5_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_6_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ItemBackgroundTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : ((::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSelected() || (state == ::vl::presentation::controls::ButtonState::Pressed)) ? ::vl::WString(L"#3399FF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#3F3F46", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - return true; - } - return false; - } - - bool __vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - __vwsnc3_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc3_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -7559,39 +7680,48 @@ Closures //------------------------------------------------------------------- - __vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) + __vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::LabelTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::HScrollTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::HScrollTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); + auto __vwsn_bind_activator_result_ = (static_cast(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetPosition()) / static_cast(::vl::__vwsn::This(__vwsn_bind_cache_1)->GetTotalSize())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + void __vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PositionChanged, ::vl::Func(this, &__vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, ::vl::Func(this, &__vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -7601,7 +7731,229 @@ Closures return false; } - bool __vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PositionChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TotalSizeChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::HScrollTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::HScrollTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::HTrackerTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::HTrackerTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::HTrackerTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = ::vl::__vwsn::This(__vwsnthis_0->behavior)->GetHorizontalTrackerHandlerPosition(__vwsnthis_0->handle, ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetTotalSize(), ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetPageSize(), ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetPosition()); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = (- static_cast<::vl::vint>(1)); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TotalSizeChanged, ::vl::Func(this, &__vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->PageSizeChanged, ::vl::Func(this, &__vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->PositionChanged, ::vl::Func(this, &__vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + return true; + } + return false; + } + + bool __vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TotalSizeChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->PageSizeChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->PositionChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::HTrackerTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::HTrackerTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::HTrackerTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ItemBackgroundTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : ((::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSelected() || (state == ::vl::presentation::controls::ButtonState::Pressed)) ? ::vl::WString(L"#3399FF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#3F3F46", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + return true; + } + return false; + } + + bool __vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ItemBackgroundTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::LabelTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -7616,7 +7968,7 @@ Closures //------------------------------------------------------------------- - __vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) + __vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::LabelTemplate*>(nullptr); @@ -7627,37 +7979,37 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>(((! ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ::vl::__vwsn::ToString(::vl::__vwsn::This(__vwsn_bind_cache_1)->GetTextColor()))); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TextColorChanged, ::vl::Func(this, &__vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->TextColorChanged, ::vl::Func(this, &__vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -7667,7 +8019,7 @@ Closures return false; } - bool __vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -7685,7 +8037,7 @@ Closures //------------------------------------------------------------------- - __vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) + __vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::LabelTemplate*>(nullptr); @@ -7694,30 +8046,30 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -7727,7 +8079,7 @@ Closures return false; } - bool __vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -7742,7 +8094,7 @@ Closures //------------------------------------------------------------------- - __vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::LeftScrollButtonTemplate*>(nullptr); @@ -7753,37 +8105,37 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -7793,7 +8145,7 @@ Closures return false; } - bool __vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -7811,7 +8163,7 @@ Closures //------------------------------------------------------------------- - __vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::LeftScrollButtonTemplate*>(nullptr); @@ -7822,37 +8174,37 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -7862,7 +8214,7 @@ Closures return false; } - bool __vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -7880,225 +8232,22 @@ Closures //------------------------------------------------------------------- - __vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#3E3E40", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#3E3E40", false) : ::vl::WString(L"#252527", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - return true; - } - return false; - } - - bool __vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#F1F1F1", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#FFFFFF", false) : ::vl::WString(L"#F1F1F1", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - __vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } void __vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#3E3E40", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#3E3E40", false) : ::vl::WString(L"#252527", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -8107,13 +8256,27 @@ Closures this->__vwsn_bind_activator_(); } + void __vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + bool __vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; @@ -8134,9 +8297,15 @@ Closures if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } return false; @@ -8148,14 +8317,18 @@ Closures :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } void __vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSubMenuOpening(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSelected()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -8164,13 +8337,27 @@ Closures this->__vwsn_bind_activator_(); } + void __vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + bool __vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; @@ -8191,9 +8378,15 @@ Closures if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuOpeningChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, __vwsn_bind_handler_2_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } return false; @@ -8274,14 +8467,18 @@ Closures :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } void __vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSubMenuExisting(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSelected()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -8290,13 +8487,27 @@ Closures this->__vwsn_bind_activator_(); } + void __vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + bool __vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuExistingChanged, ::vl::Func(this, &__vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; @@ -8317,7 +8528,70 @@ Closures if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuExistingChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = (::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSortingState() == ::vl::presentation::controls::ColumnSortingState::Ascending); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SortingStateChanged, ::vl::Func(this, &__vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SortingStateChanged, __vwsn_bind_handler_0_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -8327,12 +8601,12 @@ Closures //------------------------------------------------------------------- - __vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); @@ -8340,28 +8614,28 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#1B1B1C", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#3D3D40", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSelected()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { @@ -8369,15 +8643,15 @@ Closures (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; } - bool __vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -8387,17 +8661,17 @@ Closures return false; } - bool __vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); @@ -8408,39 +8682,57 @@ Closures //------------------------------------------------------------------- - __vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSelected()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + void __vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; } - bool __vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -8450,13 +8742,76 @@ Closures return false; } - bool __vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = (::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSortingState() == ::vl::presentation::controls::ColumnSortingState::Descending); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SortingStateChanged, ::vl::Func(this, &__vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SortingStateChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -8465,48 +8820,39 @@ Closures //------------------------------------------------------------------- - __vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ::vl::WString(L"#FFFFFF", false)); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -8516,15 +8862,81 @@ Closures return false; } - bool __vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#F1F1F1", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#FFFFFF", false) : ::vl::WString(L"#F1F1F1", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -8534,39 +8946,39 @@ Closures //------------------------------------------------------------------- - __vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -8576,13 +8988,13 @@ Closures return false; } - bool __vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -8591,57 +9003,39 @@ Closures //------------------------------------------------------------------- - __vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#3D3D40", false) : (((state == ::vl::presentation::controls::ButtonState::Active) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#3D3D40", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSubMenuOpening(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -8651,20 +9045,14 @@ Closures return false; } - bool __vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuOpeningChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } return false; @@ -8672,39 +9060,39 @@ Closures //------------------------------------------------------------------- - __vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetImage(); } catch(...){ return ::vl::Ptr<::vl::presentation::INativeImage>(); } }(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSubMenuExisting(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuExistingChanged, ::vl::Func(this, &__vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -8714,184 +9102,13 @@ Closures return false; } - bool __vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetFrameIndex(); } catch(...){ return static_cast<::vl::vint>(0); } }(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetVisuallyEnabled(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuExistingChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -8957,48 +9174,57 @@ Closures //------------------------------------------------------------------- - __vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ::vl::WString(L"#FFFFFF", false)); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#1B1B1C", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#3D3D40", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + void __vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; } - bool __vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -9008,15 +9234,144 @@ Closures return false; } - bool __vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ::vl::WString(L"#FFFFFF", false)); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -9026,39 +9381,39 @@ Closures //------------------------------------------------------------------- - __vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -9068,13 +9423,13 @@ Closures return false; } - bool __vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuBarButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -9083,144 +9438,22 @@ Closures //------------------------------------------------------------------- - __vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetShortcutText(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ShortcutTextChanged, ::vl::Func(this, &__vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ShortcutTextChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ::vl::WString(L"#FFFFFF", false)); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - __vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } void __vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#3D3D40", false) : (((state == ::vl::presentation::controls::ButtonState::Active) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#3D3D40", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -9229,13 +9462,27 @@ Closures this->__vwsn_bind_activator_(); } + void __vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + bool __vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; @@ -9256,9 +9503,15 @@ Closures if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } return false; @@ -9270,18 +9523,14 @@ Closures :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } void __vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Active) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetImage(); } catch(...){ return ::vl::Ptr<::vl::presentation::INativeImage>(); } }(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -9290,27 +9539,13 @@ Closures this->__vwsn_bind_activator_(); } - void __vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - bool __vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; @@ -9331,15 +9566,9 @@ Closures if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } return false; @@ -9351,18 +9580,14 @@ Closures :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } void __vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Active) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetFrameIndex(); } catch(...){ return static_cast<::vl::vint>(0); } }(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -9371,27 +9596,13 @@ Closures this->__vwsn_bind_activator_(); } - void __vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - bool __vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; @@ -9412,15 +9623,9 @@ Closures if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } return false; @@ -9439,7 +9644,7 @@ Closures void __vwsnc67_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSubMenuExisting(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetVisuallyEnabled(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -9454,7 +9659,7 @@ Closures { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuExistingChanged, ::vl::Func(this, &__vwsnc67_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc67_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; @@ -9475,7 +9680,7 @@ Closures if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuExistingChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, __vwsn_bind_handler_0_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -9485,75 +9690,39 @@ Closures //------------------------------------------------------------------- - __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ProgressBarTemplateConstructor* __vwsnctorthis_0) + __vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr); - this->__vwsn_bind_cache_3 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr); - this->__vwsn_bind_cache_4 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_3_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_4_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = [&](auto width, auto max){ return ((max == static_cast<::vl::vint>(0)) ? static_cast<::vl::vint>(0) : (width - ((width * ::vl::__vwsn::This(__vwsn_bind_cache_4)->GetPosition()) / max))); }((::vl::__vwsn::This(__vwsn_bind_cache_0)->GetBounds().x2 - ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetBounds().x1), (::vl::__vwsn::This(__vwsn_bind_cache_2)->GetTotalSize() - ::vl::__vwsn::This(__vwsn_bind_cache_3)->GetPageSize())); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_3_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_4_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->container); - (__vwsn_bind_cache_1 = __vwsnthis_0->container); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_cache_3 = __vwsnthis_0->self); - (__vwsn_bind_cache_4 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, ::vl::Func(this, &__vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, ::vl::Func(this, &__vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->TotalSizeChanged, ::vl::Func(this, &__vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - (__vwsn_bind_handler_3_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_3)->PageSizeChanged, ::vl::Func(this, &__vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_3_0))); - (__vwsn_bind_handler_4_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_4)->PositionChanged, ::vl::Func(this, &__vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_4_0))); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -9563,26 +9732,14 @@ Closures return false; } - bool __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->TotalSizeChanged, __vwsn_bind_handler_2_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_3)->PageSizeChanged, __vwsn_bind_handler_3_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_4)->PositionChanged, __vwsn_bind_handler_4_0); - (__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr)); - (__vwsn_bind_cache_3 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr)); - (__vwsn_bind_cache_4 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_3_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_4_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } return false; @@ -9590,48 +9747,48 @@ Closures //------------------------------------------------------------------- - __vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#252526", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#3F3F46", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ::vl::WString(L"#FFFFFF", false)); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -9641,15 +9798,15 @@ Closures return false; } - bool __vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -9728,348 +9885,39 @@ Closures //------------------------------------------------------------------- - __vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#434346", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#6A6A75", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#1C97EA", false) : ::vl::WString(L"#54545C", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#F1F1F1", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#FFFFFF", false) : ::vl::WString(L"#F1F1F1", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelected(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, ::vl::Func(this, &__vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>(((! ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ::vl::WString(L"#F1F1F1", false))); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -10079,81 +9927,588 @@ Closures return false; } - bool __vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetShortcutText(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ShortcutTextChanged, ::vl::Func(this, &__vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ShortcutTextChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ::vl::WString(L"#FFFFFF", false)); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Active) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + return true; + } + return false; + } + + bool __vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Active) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + return true; + } + return false; + } + + bool __vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSubMenuExisting(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuExistingChanged, ::vl::Func(this, &__vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SubMenuExistingChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::MenuItemButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ProgressBarTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + this->__vwsn_bind_cache_2 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr); + this->__vwsn_bind_cache_3 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr); + this->__vwsn_bind_cache_4 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_3_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_4_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = [&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = [&](auto width, auto max){ return ((max == static_cast<::vl::vint>(0)) ? static_cast<::vl::vint>(0) : (width - ((width * ::vl::__vwsn::This(__vwsn_bind_cache_4)->GetPosition()) / max))); }((::vl::__vwsn::This(__vwsn_bind_cache_0)->GetBounds().x2 - ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetBounds().x1), (::vl::__vwsn::This(__vwsn_bind_cache_2)->GetTotalSize() - ::vl::__vwsn::This(__vwsn_bind_cache_3)->GetPageSize())); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_3_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_4_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->container); + (__vwsn_bind_cache_1 = __vwsnthis_0->container); + (__vwsn_bind_cache_2 = __vwsnthis_0->self); + (__vwsn_bind_cache_3 = __vwsnthis_0->self); + (__vwsn_bind_cache_4 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, ::vl::Func(this, &__vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, ::vl::Func(this, &__vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->TotalSizeChanged, ::vl::Func(this, &__vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + (__vwsn_bind_handler_3_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_3)->PageSizeChanged, ::vl::Func(this, &__vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_3_0))); + (__vwsn_bind_handler_4_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_4)->PositionChanged, ::vl::Func(this, &__vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_4_0))); + return true; + } + return false; + } + + bool __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->BoundsChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->BoundsChanged, __vwsn_bind_handler_1_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->TotalSizeChanged, __vwsn_bind_handler_2_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_3)->PageSizeChanged, __vwsn_bind_handler_3_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_4)->PositionChanged, __vwsn_bind_handler_4_0); + (__vwsn_bind_cache_0 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr)); + (__vwsn_bind_cache_2 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr)); + (__vwsn_bind_cache_3 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr)); + (__vwsn_bind_cache_4 = static_cast<::darkskin::ProgressBarTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_3_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_4_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#252526", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#3F3F46", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -10163,48 +10518,48 @@ Closures //------------------------------------------------------------------- - __vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#434346", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#6A6A75", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#1C97EA", false) : ::vl::WString(L"#54545C", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -10214,15 +10569,15 @@ Closures return false; } - bool __vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -10232,120 +10587,6 @@ Closures //------------------------------------------------------------------- - __vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ShortcutKeyTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ShortcutKeyTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ShortcutKeyTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetTextColor(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextColorChanged, ::vl::Func(this, &__vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextColorChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ShortcutKeyTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - __vwsnc7_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc7_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -10403,39 +10644,48 @@ Closures //------------------------------------------------------------------- - __vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) + __vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ShortcutKeyTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#F1F1F1", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#FFFFFF", false) : ::vl::WString(L"#F1F1F1", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + void __vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); return true; } return false; } - bool __vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -10445,12 +10695,438 @@ Closures return false; } - bool __vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelected(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, ::vl::Func(this, &__vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>(((! ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ::vl::WString(L"#F1F1F1", false))); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::RadioButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#007ACC", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::RightScrollButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ShortcutKeyTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); (__vwsn_bind_cache_0 = static_cast<::darkskin::ShortcutKeyTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -10460,48 +11136,39 @@ Closures //------------------------------------------------------------------- - __vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ShortcutKeyTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return (::vl::__vwsn::This(__vwsn_bind_cache_1)->GetSelected() ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1C97EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#1C97EA", false) : ::vl::WString(L"#434346", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetTextColor(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextColorChanged, ::vl::Func(this, &__vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -10511,73 +11178,13 @@ Closures return false; } - bool __vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextColorChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ShortcutKeyTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -10586,108 +11193,39 @@ Closures //------------------------------------------------------------------- - __vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) + __vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#F1F1F1", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#FFFFFF", false) : ::vl::WString(L"#F1F1F1", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::darkskin::ShortcutKeyTemplate*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -10697,13 +11235,13 @@ Closures return false; } - bool __vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_0 = static_cast<::darkskin::ShortcutKeyTemplate*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -10712,315 +11250,6 @@ Closures //------------------------------------------------------------------- - __vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTabPage*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->CurrentTabPage); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTabPage*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTabPage*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetAlt(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->CurrentTabPage); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->AltChanged, ::vl::Func(this, &__vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->AltChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTabPage*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTab*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = (::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelectedPage() == __vwsnthis_0->CurrentTabPage); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = ::vl::__vwsn::This(__vwsnthis_0->CurrentTabPage)->GetOwnerTab()); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedPageChanged, ::vl::Func(this, &__vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedPageChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTab*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::TabTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetTabPages(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TabPagesChanged, ::vl::Func(this, &__vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TabPagesChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::TabTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSelected()) ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - return true; - } - return false; - } - - bool __vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - __vwsnc8_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc8_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::CheckBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -11090,7 +11319,487 @@ Closures //------------------------------------------------------------------- - __vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0) + __vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return (::vl::__vwsn::This(__vwsn_bind_cache_1)->GetSelected() ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1C97EA", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#1C97EA", false) : ::vl::WString(L"#434346", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); + this->__vwsn_bind_cache_1 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#6D6D6D", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#F1F1F1", false) : ((state == ::vl::presentation::controls::ButtonState::Pressed) ? ::vl::WString(L"#FFFFFF", false) : ::vl::WString(L"#F1F1F1", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + void __vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_cache_1 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + return true; + } + return false; + } + + bool __vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); + (__vwsn_bind_cache_1 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::TabHeaderButtonTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTabPage*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->CurrentTabPage); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTabPage*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTabPage*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetAlt(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->CurrentTabPage); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->AltChanged, ::vl::Func(this, &__vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->AltChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTabPage*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTab*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = (::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelectedPage() == __vwsnthis_0->CurrentTabPage); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = ::vl::__vwsn::This(__vwsnthis_0->CurrentTabPage)->GetOwnerTab()); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedPageChanged, ::vl::Func(this, &__vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedPageChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiTab*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::darkskin::TabTemplate*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetTabPages(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TabPagesChanged, ::vl::Func(this, &__vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TabPagesChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::darkskin::TabTemplate*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr); @@ -11103,28 +11812,28 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSelected()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSelected()) ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { @@ -11132,15 +11841,15 @@ Closures (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; } - bool __vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -11150,7 +11859,7 @@ Closures return false; } - bool __vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -11171,7 +11880,7 @@ Closures //------------------------------------------------------------------- - __vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0) + __vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripSplitArrowTemplate*>(nullptr); @@ -11184,28 +11893,28 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#555558", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSelected()) ? ::vl::WString(L"#FFFFFF", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#1997EA", false) : ::vl::WString(L"#999999", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - void __vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { @@ -11213,15 +11922,15 @@ Closures (__vwsn_bind_cache_0 = __vwsnthis_0->self); (__vwsn_bind_cache_1 = __vwsnthis_0->self); (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); + (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SelectedChanged, ::vl::Func(this, &__vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); return true; } return false; } - bool __vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -11231,7 +11940,7 @@ Closures return false; } - bool __vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -11252,534 +11961,6 @@ Closures //------------------------------------------------------------------- - __vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetSelected()) ? ::vl::WString(L"#00000000", false) : ::vl::WString(L"#007ACC", false)); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - return true; - } - return false; - } - - bool __vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetImage(); } catch(...){ return ::vl::Ptr<::vl::presentation::INativeImage>(); } }(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetFrameIndex(); } catch(...){ return static_cast<::vl::vint>(0); } }(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetVisuallyEnabled(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->VisuallyEnabledChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetSelected()) ? ::vl::WString(L"#00000000", false) : ::vl::WString(L"#007ACC", false)); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, ::vl::Func(this, &__vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - return true; - } - return false; - } - - bool __vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->SelectedChanged, __vwsn_bind_handler_1_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Parse<::vl::presentation::Color>([&](auto state){ return ((! ::vl::__vwsn::This(__vwsn_bind_cache_1)->GetVisuallyEnabled()) ? ::vl::WString(L"#00000000", false) : (((state == ::vl::presentation::controls::ButtonState::Pressed) || ::vl::__vwsn::This(__vwsn_bind_cache_2)->GetSubMenuOpening()) ? ::vl::WString(L"#007ACC", false) : ((state == ::vl::presentation::controls::ButtonState::Active) ? ::vl::WString(L"#54545C", false) : ::vl::WString(L"#00000000", false)))); }(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetState())); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - void __vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_cache_1 = __vwsnthis_0->self); - (__vwsn_bind_cache_2 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, ::vl::Func(this, &__vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - (__vwsn_bind_handler_1_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, ::vl::Func(this, &__vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_1_0))); - (__vwsn_bind_handler_2_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, ::vl::Func(this, &__vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_2_0))); - return true; - } - return false; - } - - bool __vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->StateChanged, __vwsn_bind_handler_0_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_1)->VisuallyEnabledChanged, __vwsn_bind_handler_1_0); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_2)->SubMenuOpeningChanged, __vwsn_bind_handler_2_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_1 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_cache_2 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_1_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - (__vwsn_bind_handler_2_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::This(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetImage().Obj())->GetImage(); } catch(...){ return ::vl::Ptr<::vl::presentation::INativeImage>(); } }(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, ::vl::Func(this, &__vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->ImageChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::darkskin::ToolstripDropdownButtonTemplate*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - __vwsnc9_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc9_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::CheckBoxTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -12612,27 +12793,50 @@ Class (::darkskin::DatePickerTemplateConstructor) void DatePickerTemplateConstructor::__vwsn_initialize_instance_(::darkskin::DatePickerTemplate* __vwsn_this_) { (this->self = __vwsn_this_); - { - ::vl::__vwsn::This(this->self)->SetSecondaryTextColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#999999", false))); - } - { - ::vl::__vwsn::This(this->self)->SetPrimaryTextColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#FFFFFF", false))); - } - { - ::vl::__vwsn::This(this->self)->SetDateComboBoxTemplate(LAMBDA(::vl_workflow_global::__vwsnf62_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetDateTextListTemplate(LAMBDA(::vl_workflow_global::__vwsnf63_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetDateButtonTemplate(LAMBDA(::vl_workflow_global::__vwsnf64_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetBackgroundColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#2D2D30", false))); - } { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } + (this->look = new ::vl::presentation::templates::GuiCommonDatePickerLook(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#2D2D30", false)), ::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#FFFFFF", false)), ::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#999999", false)))); + { + ::vl::__vwsn::This(this->look)->SetDateComboBoxTemplate(LAMBDA(::vl_workflow_global::__vwsnf62_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(this))); + } + { + ::vl::__vwsn::This(this->look)->SetDateTextListTemplate(LAMBDA(::vl_workflow_global::__vwsnf63_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(this))); + } + { + ::vl::__vwsn::This(this->look)->SetDateButtonTemplate(LAMBDA(::vl_workflow_global::__vwsnf64_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(this))); + } + { + ::vl::__vwsn::This(this->look)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->look)); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf65_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf66_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf67_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf68_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf69_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } } DatePickerTemplateConstructor::DatePickerTemplateConstructor() @@ -12771,15 +12975,6 @@ Class (::darkskin::DocumentViewerTemplateConstructor) void DocumentViewerTemplateConstructor::__vwsn_initialize_instance_(::darkskin::DocumentViewerTemplate* __vwsn_this_) { (this->self = __vwsn_this_); - { - ::vl::__vwsn::This(this->self)->SetDefaultScrollSize(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false))); - } - { - ::vl::__vwsn::This(this->self)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf65_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf66_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(this))); - } { ::vl::__vwsn::This(this->self)->SetCaretColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#FFFFFF", false))); } @@ -12793,32 +12988,51 @@ Class (::darkskin::DocumentViewerTemplateConstructor) { ::vl::__vwsn::This(this->self)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_0)); } - (this->container = new ::vl::presentation::compositions::GuiBoundsComposition()); + (this->__vwsn_precompile_1 = new ::vl::presentation::compositions::GuiBoundsComposition()); { - ::vl::__vwsn::This(this->container)->SetInternalMargin([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(1); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetInternalMargin([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(1); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->container)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->container)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } - (this->__vwsn_precompile_1 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBorderElement>())); + (this->__vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBorderElement>())); { - ::vl::__vwsn::This(this->__vwsn_precompile_1.Obj())->SetColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#3F3F46", false))); + ::vl::__vwsn::This(this->__vwsn_precompile_2.Obj())->SetColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#3F3F46", false))); } { - ::vl::__vwsn::This(this->container)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_1)); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_2)); + } + (this->look = new ::vl::presentation::templates::GuiCommonScrollViewLook(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false)))); + { + ::vl::__vwsn::This(this->look)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf70_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + ::vl::__vwsn::This(this->look)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf71_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + ::vl::__vwsn::This(this->look)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_1)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->look)); + } + { + ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); + } + { + ::vl::__vwsn::This(this->self)->SetContainerComposition(::vl::__vwsn::This(this->look)->GetContainerComposition()); } { ::vl::__vwsn::This(this->self)->SetBaselineDocument(::vl::__vwsn::Ensure(::vl::__vwsn::SharedPtrCast<::vl::presentation::DocumentModel>(::vl::__vwsn::This(__vwsn_this_)->ResolveResource(::vl::WString(L"res", false), ::vl::WString(L"DarkSkin/BaselineDocument", false), true).Obj()))); } + { + ::vl::__vwsn::This(this->self)->SetHorizontalScroll(::vl::__vwsn::This(this->look)->GetHScroll()); + } + { + ::vl::__vwsn::This(this->self)->SetVerticalScroll(::vl::__vwsn::This(this->look)->GetVScroll()); + } } DocumentViewerTemplateConstructor::DocumentViewerTemplateConstructor() @@ -12912,36 +13126,36 @@ Class (::darkskin::ExpandingDecoratorTemplateConstructor) { ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf67_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf68_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf69_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf70_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf71_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } { auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf72_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf73_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf74_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf75_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf76_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf77_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } } ExpandingDecoratorTemplateConstructor::ExpandingDecoratorTemplateConstructor() @@ -13044,18 +13258,18 @@ Class (::darkskin::GroupBoxTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->titleBounds)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf73_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf78_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf74_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf79_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf75_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf80_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { @@ -13109,8 +13323,8 @@ Class (::darkskin::HScrollHandleTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf76_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf81_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -13146,15 +13360,9 @@ Class (::darkskin::HScrollTemplateConstructor) { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } - (this->invalidContainer = new ::vl::presentation::compositions::GuiBoundsComposition()); + (this->behavior = new ::vl::presentation::templates::GuiCommonScrollBehavior()); { - ::vl::__vwsn::This(this->invalidContainer)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); - } - { - ::vl::__vwsn::This(this->invalidContainer)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); - } - { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->invalidContainer)); + ::vl::__vwsn::This(this->self)->AddComponent(static_cast<::vl::presentation::controls::GuiComponent*>(this->behavior)); } (this->__vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBackgroundElement>())); { @@ -13174,46 +13382,46 @@ Class (::darkskin::HScrollTemplateConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetDirection(::vl::presentation::compositions::GuiSideAlignedComposition::Direction::Left); } { - (this->__vwsn_precompile_2 = new ::vl::presentation::controls::GuiButton(::vl::presentation::theme::ThemeName::Button)); + (this->buttonDecrease = new ::vl::presentation::controls::GuiButton(::vl::presentation::theme::ThemeName::Button)); } - (this->__vwsn_precompile_3 = ::vl::__vwsn::This(this->__vwsn_precompile_2)->GetBoundsComposition()); + (this->__vwsn_precompile_2 = ::vl::__vwsn::This(this->buttonDecrease)->GetBoundsComposition()); { - ::vl::__vwsn::This(this->__vwsn_precompile_3)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_2)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->__vwsn_precompile_2)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf77_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->buttonDecrease)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf82_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->__vwsn_precompile_1)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_2)->GetBoundsComposition())); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->buttonDecrease)->GetBoundsComposition())); } { ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); } - (this->__vwsn_precompile_4 = new ::vl::presentation::compositions::GuiSideAlignedComposition()); + (this->__vwsn_precompile_3 = new ::vl::presentation::compositions::GuiSideAlignedComposition()); { - ::vl::__vwsn::This(this->__vwsn_precompile_4)->SetMaxRatio(::vl::__vwsn::Parse(::vl::WString(L"0.5", false))); + ::vl::__vwsn::This(this->__vwsn_precompile_3)->SetMaxRatio(::vl::__vwsn::Parse(::vl::WString(L"0.5", false))); } { - ::vl::__vwsn::This(this->__vwsn_precompile_4)->SetMaxLength(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false))); + ::vl::__vwsn::This(this->__vwsn_precompile_3)->SetMaxLength(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false))); } { - ::vl::__vwsn::This(this->__vwsn_precompile_4)->SetDirection(::vl::presentation::compositions::GuiSideAlignedComposition::Direction::Right); + ::vl::__vwsn::This(this->__vwsn_precompile_3)->SetDirection(::vl::presentation::compositions::GuiSideAlignedComposition::Direction::Right); } { - (this->__vwsn_precompile_5 = new ::vl::presentation::controls::GuiButton(::vl::presentation::theme::ThemeName::Button)); + (this->buttonIncrease = new ::vl::presentation::controls::GuiButton(::vl::presentation::theme::ThemeName::Button)); } - (this->__vwsn_precompile_6 = ::vl::__vwsn::This(this->__vwsn_precompile_5)->GetBoundsComposition()); + (this->__vwsn_precompile_4 = ::vl::__vwsn::This(this->buttonIncrease)->GetBoundsComposition()); { - ::vl::__vwsn::This(this->__vwsn_precompile_6)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_4)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf78_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->buttonIncrease)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf83_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->__vwsn_precompile_4)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_5)->GetBoundsComposition())); + ::vl::__vwsn::This(this->__vwsn_precompile_3)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->buttonIncrease)->GetBoundsComposition())); } { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_4)); + ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_3)); } (this->handleContainer = new ::vl::presentation::compositions::GuiBoundsComposition()); { @@ -13222,33 +13430,19 @@ Class (::darkskin::HScrollTemplateConstructor) { ::vl::__vwsn::This(this->handleContainer)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::NoLimit); } - (this->__vwsn_precompile_7 = new ::vl::presentation::compositions::GuiBoundsComposition()); - { - ::vl::__vwsn::This(this->__vwsn_precompile_7)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); - } - { - ::vl::__vwsn::This(this->handleContainer)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_7)); - } - (this->__vwsn_precompile_8 = new ::vl::presentation::compositions::GuiBoundsComposition()); - { - ::vl::__vwsn::This(this->__vwsn_precompile_8)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); - } - { - ::vl::__vwsn::This(this->handleContainer)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_8)); - } (this->handle = new ::vl::presentation::compositions::GuiPartialViewComposition()); { - (this->__vwsn_precompile_9 = new ::vl::presentation::controls::GuiButton(::vl::presentation::theme::ThemeName::Button)); + (this->__vwsn_precompile_5 = new ::vl::presentation::controls::GuiButton(::vl::presentation::theme::ThemeName::Button)); } - (this->__vwsn_precompile_10 = ::vl::__vwsn::This(this->__vwsn_precompile_9)->GetBoundsComposition()); + (this->__vwsn_precompile_6 = ::vl::__vwsn::This(this->__vwsn_precompile_5)->GetBoundsComposition()); { - ::vl::__vwsn::This(this->__vwsn_precompile_10)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_6)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->__vwsn_precompile_9)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf79_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf84_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->handle)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_9)->GetBoundsComposition())); + ::vl::__vwsn::This(this->handle)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_5)->GetBoundsComposition())); } { ::vl::__vwsn::This(this->handleContainer)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->handle)); @@ -13257,56 +13451,15 @@ Class (::darkskin::HScrollTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->handleContainer)); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf80_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_2)->Clicked, __vwsn_event_handler_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf81_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_5)->Clicked, __vwsn_event_handler_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf82_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf85_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf83_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_7)->GetEventReceiver()->leftButtonDown, __vwsn_event_handler_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf84_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf85_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_8)->GetEventReceiver()->leftButtonDown, __vwsn_event_handler_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf86_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf87_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf88_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->leftButtonDown, __vwsn_event_handler_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf89_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->leftButtonUp, __vwsn_event_handler_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf90_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->mouseMove, __vwsn_event_handler_); - } - { - ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->invalidContainer)); - } } HScrollTemplateConstructor::HScrollTemplateConstructor() @@ -13323,6 +13476,15 @@ Class (::darkskin::HScrollTemplate) auto __vwsn_resolver_ = ::vl::Ptr<::vl::presentation::GuiResourcePathResolver>(new ::vl::presentation::GuiResourcePathResolver(__vwsn_resource_, ::vl::__vwsn::This(__vwsn_resource_.Obj())->GetWorkingDirectory())); ::vl::__vwsn::This(this)->SetResourceResolver(__vwsn_resolver_); ::vl::__vwsn::This(this)->__vwsn_initialize_instance_(this); + this->__vwsn_instance_ctor_(); + } + + void HScrollTemplate::__vwsn_instance_ctor_() + { + ::vl::__vwsn::This(this->behavior)->AttachScrollTemplate(static_cast<::vl::presentation::templates::GuiScrollTemplate*>(this->self)); + ::vl::__vwsn::This(this->behavior)->AttachDecreaseButton(this->buttonDecrease); + ::vl::__vwsn::This(this->behavior)->AttachIncreaseButton(this->buttonIncrease); + ::vl::__vwsn::This(this->behavior)->AttachHorizontalPartialView(this->handle); } HScrollTemplate::~HScrollTemplate() @@ -13340,15 +13502,9 @@ Class (::darkskin::HTrackerTemplateConstructor) { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } - (this->invalidContainer = new ::vl::presentation::compositions::GuiBoundsComposition()); + (this->behavior = new ::vl::presentation::templates::GuiCommonScrollBehavior()); { - ::vl::__vwsn::This(this->invalidContainer)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); - } - { - ::vl::__vwsn::This(this->invalidContainer)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); - } - { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->invalidContainer)); + ::vl::__vwsn::This(this->self)->AddComponent(static_cast<::vl::presentation::controls::GuiComponent*>(this->behavior)); } (this->__vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBackgroundElement>())); { @@ -13420,7 +13576,7 @@ Class (::darkskin::HTrackerTemplateConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_7)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->__vwsn_precompile_6)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf91_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->__vwsn_precompile_6)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf87_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->handle)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_6)->GetBoundsComposition())); @@ -13432,25 +13588,10 @@ Class (::darkskin::HTrackerTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf92_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf88_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf93_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->leftButtonDown, __vwsn_event_handler_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf94_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->leftButtonUp, __vwsn_event_handler_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf95_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->mouseMove, __vwsn_event_handler_); - } - { - ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->invalidContainer)); - } } HTrackerTemplateConstructor::HTrackerTemplateConstructor() @@ -13467,6 +13608,13 @@ Class (::darkskin::HTrackerTemplate) auto __vwsn_resolver_ = ::vl::Ptr<::vl::presentation::GuiResourcePathResolver>(new ::vl::presentation::GuiResourcePathResolver(__vwsn_resource_, ::vl::__vwsn::This(__vwsn_resource_.Obj())->GetWorkingDirectory())); ::vl::__vwsn::This(this)->SetResourceResolver(__vwsn_resolver_); ::vl::__vwsn::This(this)->__vwsn_initialize_instance_(this); + this->__vwsn_instance_ctor_(); + } + + void HTrackerTemplate::__vwsn_instance_ctor_() + { + ::vl::__vwsn::This(this->behavior)->AttachScrollTemplate(static_cast<::vl::presentation::templates::GuiScrollTemplate*>(this->self)); + ::vl::__vwsn::This(this->behavior)->AttachHorizontalTrackerHandle(this->handle); } HTrackerTemplate::~HTrackerTemplate() @@ -13499,8 +13647,8 @@ Class (::darkskin::ItemBackgroundTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf96_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf89_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { @@ -13547,18 +13695,18 @@ Class (::darkskin::LabelTemplateConstructor) ::vl::__vwsn::This(this->self)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_0)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf97_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf90_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf98_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf91_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf99_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf92_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -13631,13 +13779,13 @@ Class (::darkskin::LeftScrollButtonTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf100_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf93_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf101_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf94_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -13671,7 +13819,7 @@ Class (::darkskin::ListViewColumnHeaderTemplateConstructor) { (this->self = __vwsn_this_); { - ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf102_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf95_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); @@ -13720,92 +13868,184 @@ Class (::darkskin::ListViewColumnHeaderTemplateConstructor) { ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_3)); } - (this->__vwsn_precompile_5 = new ::vl::presentation::compositions::GuiBoundsComposition()); + (this->container = new ::vl::presentation::compositions::GuiBoundsComposition()); { - ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(11); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->container)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(11); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->container)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); + } + (this->__vwsn_precompile_5 = new ::vl::presentation::compositions::GuiTableComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = (- static_cast<::vl::vint>(1)); return __vwsn_temp__; }()); } { ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } - (this->__vwsn_precompile_6 = new ::vl::presentation::compositions::GuiBoundsComposition()); { - ::vl::__vwsn::This(this->__vwsn_precompile_6)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(8); __vwsn_temp__.top = static_cast<::vl::vint>(5); __vwsn_temp__.right = static_cast<::vl::vint>(5); __vwsn_temp__.bottom = static_cast<::vl::vint>(5); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetRowsAndColumns(static_cast<::vl::vint>(2), static_cast<::vl::vint>(3)); + ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetRowOption(static_cast<::vl::vint>(0), [&](){ ::vl::presentation::compositions::GuiCellOption __vwsn_temp__; __vwsn_temp__.composeType = ::vl::presentation::compositions::GuiCellOption::ComposeType::MinSize; return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetRowOption(static_cast<::vl::vint>(1), [&](){ ::vl::presentation::compositions::GuiCellOption __vwsn_temp__; __vwsn_temp__.composeType = ::vl::presentation::compositions::GuiCellOption::ComposeType::Percentage; __vwsn_temp__.percentage = static_cast(1.0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetColumnOption(static_cast<::vl::vint>(0), [&](){ ::vl::presentation::compositions::GuiCellOption __vwsn_temp__; __vwsn_temp__.composeType = ::vl::presentation::compositions::GuiCellOption::ComposeType::Percentage; __vwsn_temp__.percentage = static_cast(0.5); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetColumnOption(static_cast<::vl::vint>(1), [&](){ ::vl::presentation::compositions::GuiCellOption __vwsn_temp__; __vwsn_temp__.composeType = ::vl::presentation::compositions::GuiCellOption::ComposeType::MinSize; return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetColumnOption(static_cast<::vl::vint>(2), [&](){ ::vl::presentation::compositions::GuiCellOption __vwsn_temp__; __vwsn_temp__.composeType = ::vl::presentation::compositions::GuiCellOption::ComposeType::Percentage; __vwsn_temp__.percentage = static_cast(0.5); return __vwsn_temp__; }()); + } + (this->__vwsn_precompile_6 = new ::vl::presentation::compositions::GuiCellComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_6)->SetSite(static_cast<::vl::vint>(0), static_cast<::vl::vint>(1), static_cast<::vl::vint>(1), static_cast<::vl::vint>(1)); + } + (this->__vwsn_precompile_7 = new ::vl::presentation::compositions::GuiBoundsComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_7)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); + } + (this->__vwsn_precompile_8 = ::vl::Ptr<::vl::presentation::elements::GuiPolygonElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiPolygonElement>())); + { + [&]()->decltype(auto){ auto __vwsn_temp_x0 = ::vl::__vwsn::Box(::vl::Ptr<::vl::reflection::description::IValueReadonlyList>((::vl::__vwsn::CreateList().Add([&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(0); __vwsn_temp__.y = static_cast<::vl::vint>(3); return __vwsn_temp__; }()).Add([&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(3); __vwsn_temp__.y = static_cast<::vl::vint>(0); return __vwsn_temp__; }()).Add([&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(6); __vwsn_temp__.y = static_cast<::vl::vint>(3); return __vwsn_temp__; }())).list)); ::vl::collections::Array<::vl::presentation::Point> __vwsn_temp_0; ::vl::reflection::description::UnboxParameter(__vwsn_temp_x0, __vwsn_temp_0); return ::vl::__vwsn::This(this->__vwsn_precompile_8.Obj())->SetPointsArray(__vwsn_temp_0); }(); } { - ::vl::__vwsn::This(this->__vwsn_precompile_6)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); - } - (this->__vwsn_precompile_7 = ::vl::Ptr<::vl::presentation::elements::GuiSolidLabelElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidLabelElement>())); - { - ::vl::__vwsn::This(this->__vwsn_precompile_7.Obj())->SetEllipse(::vl::__vwsn::Parse(::vl::WString(L"true", false))); + ::vl::__vwsn::This(this->__vwsn_precompile_8.Obj())->SetSize([&](){ ::vl::presentation::Size __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(7); __vwsn_temp__.y = static_cast<::vl::vint>(4); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->__vwsn_precompile_7.Obj())->SetVerticalAlignment(::vl::presentation::Alignment::Center); + ::vl::__vwsn::This(this->__vwsn_precompile_7)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_8)); } { - ::vl::__vwsn::This(this->__vwsn_precompile_7.Obj())->SetHorizontalAlignment(::vl::presentation::Alignment::Left); + ::vl::__vwsn::This(this->__vwsn_precompile_6)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_7)); + } + (this->__vwsn_precompile_9 = new ::vl::presentation::compositions::GuiBoundsComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_9)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); + } + (this->__vwsn_precompile_10 = ::vl::Ptr<::vl::presentation::elements::GuiPolygonElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiPolygonElement>())); + { + [&]()->decltype(auto){ auto __vwsn_temp_x0 = ::vl::__vwsn::Box(::vl::Ptr<::vl::reflection::description::IValueReadonlyList>((::vl::__vwsn::CreateList().Add([&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(0); __vwsn_temp__.y = static_cast<::vl::vint>(0); return __vwsn_temp__; }()).Add([&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(3); __vwsn_temp__.y = static_cast<::vl::vint>(3); return __vwsn_temp__; }()).Add([&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(6); __vwsn_temp__.y = static_cast<::vl::vint>(0); return __vwsn_temp__; }())).list)); ::vl::collections::Array<::vl::presentation::Point> __vwsn_temp_0; ::vl::reflection::description::UnboxParameter(__vwsn_temp_x0, __vwsn_temp_0); return ::vl::__vwsn::This(this->__vwsn_precompile_10.Obj())->SetPointsArray(__vwsn_temp_0); }(); } { - ::vl::__vwsn::This(this->__vwsn_precompile_6)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_7)); + ::vl::__vwsn::This(this->__vwsn_precompile_10.Obj())->SetSize([&](){ ::vl::presentation::Size __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(7); __vwsn_temp__.y = static_cast<::vl::vint>(4); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_9)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_10)); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_6)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_9)); } { ::vl::__vwsn::This(this->__vwsn_precompile_5)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_6)); } { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_5)); + ::vl::__vwsn::This(this->container)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_5)); } - (this->__vwsn_precompile_8 = new ::vl::presentation::compositions::GuiBoundsComposition()); + (this->__vwsn_precompile_11 = new ::vl::presentation::compositions::GuiBoundsComposition()); { - ::vl::__vwsn::This(this->__vwsn_precompile_8)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = (- static_cast<::vl::vint>(1)); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_11)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(8); __vwsn_temp__.top = static_cast<::vl::vint>(6); __vwsn_temp__.right = static_cast<::vl::vint>(5); __vwsn_temp__.bottom = static_cast<::vl::vint>(5); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->__vwsn_precompile_8)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); + ::vl::__vwsn::This(this->__vwsn_precompile_11)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); + } + (this->__vwsn_precompile_12 = ::vl::Ptr<::vl::presentation::elements::GuiSolidLabelElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidLabelElement>())); + { + ::vl::__vwsn::This(this->__vwsn_precompile_12.Obj())->SetEllipse(::vl::__vwsn::Parse(::vl::WString(L"true", false))); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_12.Obj())->SetVerticalAlignment(::vl::presentation::Alignment::Center); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_12.Obj())->SetHorizontalAlignment(::vl::presentation::Alignment::Left); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_11)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_12)); + } + { + ::vl::__vwsn::This(this->container)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_11)); + } + { + ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + } + (this->__vwsn_precompile_13 = new ::vl::presentation::compositions::GuiBoundsComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_13)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = (- static_cast<::vl::vint>(1)); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_13)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } { (this->buttonArrow = new ::vl::presentation::controls::GuiSelectableButton(::vl::presentation::theme::ThemeName::CheckBox)); } - (this->__vwsn_precompile_9 = ::vl::__vwsn::This(this->buttonArrow)->GetBoundsComposition()); + (this->__vwsn_precompile_14 = ::vl::__vwsn::This(this->buttonArrow)->GetBoundsComposition()); { - ::vl::__vwsn::This(this->__vwsn_precompile_9)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_14)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->buttonArrow)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf103_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->buttonArrow)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf96_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->__vwsn_precompile_8)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->buttonArrow)->GetBoundsComposition())); + ::vl::__vwsn::This(this->__vwsn_precompile_13)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->buttonArrow)->GetBoundsComposition())); } { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_8)); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf104_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf105_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf106_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_13)); } { auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf107_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf97_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf108_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf98_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf109_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf99_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf100_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf101_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf102_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf103_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf104_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf105_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf106_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf107_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf108_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + } { ::vl::__vwsn::This(this->self)->SetSubMenuHost(static_cast<::vl::presentation::controls::GuiButton*>(this->buttonArrow)); } @@ -13843,7 +14083,13 @@ Class (::darkskin::ListViewTemplateConstructor) ::vl::__vwsn::This(this->self)->SetItemSeparatorColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#F1F1F1", false))); } { - ::vl::__vwsn::This(this->self)->SetColumnHeaderTemplate(LAMBDA(::vl_workflow_global::__vwsnf110_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetColumnHeaderTemplate(LAMBDA(::vl_workflow_global::__vwsnf109_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(this))); + } + { + ::vl::__vwsn::This(this->self)->SetBackgroundTemplate(LAMBDA(::vl_workflow_global::__vwsnf110_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(this))); + } + { + ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } { ::vl::__vwsn::This(this->self)->SetSecondaryTextColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#F1F1F1", false))); @@ -13851,21 +14097,6 @@ Class (::darkskin::ListViewTemplateConstructor) { ::vl::__vwsn::This(this->self)->SetPrimaryTextColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#F1F1F1", false))); } - { - ::vl::__vwsn::This(this->self)->SetBackgroundTemplate(LAMBDA(::vl_workflow_global::__vwsnf111_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetDefaultScrollSize(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false))); - } - { - ::vl::__vwsn::This(this->self)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf112_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf113_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); - } (this->__vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBackgroundElement>())); { ::vl::__vwsn::This(this->__vwsn_precompile_0.Obj())->SetColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#252526", false))); @@ -13873,28 +14104,47 @@ Class (::darkskin::ListViewTemplateConstructor) { ::vl::__vwsn::This(this->self)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_0)); } - (this->container = new ::vl::presentation::compositions::GuiBoundsComposition()); + (this->__vwsn_precompile_1 = new ::vl::presentation::compositions::GuiBoundsComposition()); { - ::vl::__vwsn::This(this->container)->SetInternalMargin([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(1); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetInternalMargin([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(1); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->container)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->container)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } - (this->__vwsn_precompile_1 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBorderElement>())); + (this->__vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBorderElement>())); { - ::vl::__vwsn::This(this->__vwsn_precompile_1.Obj())->SetColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#3F3F46", false))); + ::vl::__vwsn::This(this->__vwsn_precompile_2.Obj())->SetColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#3F3F46", false))); } { - ::vl::__vwsn::This(this->container)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_1)); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_2)); + } + (this->look = new ::vl::presentation::templates::GuiCommonScrollViewLook(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false)))); + { + ::vl::__vwsn::This(this->look)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf111_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + ::vl::__vwsn::This(this->look)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf112_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + ::vl::__vwsn::This(this->look)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_1)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->look)); + } + { + ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); + } + { + ::vl::__vwsn::This(this->self)->SetContainerComposition(::vl::__vwsn::This(this->look)->GetContainerComposition()); + } + { + ::vl::__vwsn::This(this->self)->SetHorizontalScroll(::vl::__vwsn::This(this->look)->GetHScroll()); + } + { + ::vl::__vwsn::This(this->self)->SetVerticalScroll(::vl::__vwsn::This(this->look)->GetVScroll()); } } @@ -13927,7 +14177,7 @@ Class (::darkskin::MenuBarButtonTemplateConstructor) { (this->self = __vwsn_this_); { - ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf114_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf113_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); @@ -13957,25 +14207,25 @@ Class (::darkskin::MenuBarButtonTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf114_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf115_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf116_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf117_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf118_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } } MenuBarButtonTemplateConstructor::MenuBarButtonTemplateConstructor() @@ -14007,7 +14257,7 @@ Class (::darkskin::MenuItemButtonTemplateConstructor) { (this->self = __vwsn_this_); { - ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf119_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf118_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); @@ -14132,69 +14382,69 @@ Class (::darkskin::MenuItemButtonTemplateConstructor) { ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf120_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf121_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf122_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf123_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf124_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf125_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf126_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf127_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf128_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } { auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf129_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf119_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf130_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf120_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf131_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf121_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc67_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf132_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf122_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf123_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf124_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf125_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf126_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf127_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf128_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf129_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf130_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf131_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -14287,15 +14537,6 @@ Class (::darkskin::MultilineTextBoxTemplateConstructor) void MultilineTextBoxTemplateConstructor::__vwsn_initialize_instance_(::darkskin::MultilineTextBoxTemplate* __vwsn_this_) { (this->self = __vwsn_this_); - { - ::vl::__vwsn::This(this->self)->SetDefaultScrollSize(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false))); - } - { - ::vl::__vwsn::This(this->self)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf133_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf134_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__(this))); - } { ::vl::__vwsn::This(this->self)->SetTextColor([&](){ ::vl::presentation::elements::text::ColorEntry __vwsn_temp__; __vwsn_temp__.normal = [&](){ ::vl::presentation::elements::text::ColorItem __vwsn_temp__; __vwsn_temp__.text = ::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#FFFFFF", false)); __vwsn_temp__.background = ::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#00000000", false)); return __vwsn_temp__; }(); __vwsn_temp__.selectedFocused = [&](){ ::vl::presentation::elements::text::ColorItem __vwsn_temp__; __vwsn_temp__.text = ::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#FFFFFF", false)); __vwsn_temp__.background = ::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#007ACC", false)); return __vwsn_temp__; }(); __vwsn_temp__.selectedUnfocused = [&](){ ::vl::presentation::elements::text::ColorItem __vwsn_temp__; __vwsn_temp__.text = ::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#FFFFFF", false)); __vwsn_temp__.background = ::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#007ACC", false)); return __vwsn_temp__; }(); return __vwsn_temp__; }()); } @@ -14312,28 +14553,47 @@ Class (::darkskin::MultilineTextBoxTemplateConstructor) { ::vl::__vwsn::This(this->self)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_0)); } - (this->container = new ::vl::presentation::compositions::GuiBoundsComposition()); + (this->__vwsn_precompile_1 = new ::vl::presentation::compositions::GuiBoundsComposition()); { - ::vl::__vwsn::This(this->container)->SetInternalMargin([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(1); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetInternalMargin([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(1); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->container)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->container)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } - (this->__vwsn_precompile_1 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBorderElement>())); + (this->__vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBorderElement>())); { - ::vl::__vwsn::This(this->__vwsn_precompile_1.Obj())->SetColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#3F3F46", false))); + ::vl::__vwsn::This(this->__vwsn_precompile_2.Obj())->SetColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#3F3F46", false))); } { - ::vl::__vwsn::This(this->container)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_1)); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_2)); + } + (this->look = new ::vl::presentation::templates::GuiCommonScrollViewLook(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false)))); + { + ::vl::__vwsn::This(this->look)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf132_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + ::vl::__vwsn::This(this->look)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf133_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + ::vl::__vwsn::This(this->look)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_1)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->look)); + } + { + ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); + } + { + ::vl::__vwsn::This(this->self)->SetContainerComposition(::vl::__vwsn::This(this->look)->GetContainerComposition()); + } + { + ::vl::__vwsn::This(this->self)->SetHorizontalScroll(::vl::__vwsn::This(this->look)->GetHScroll()); + } + { + ::vl::__vwsn::This(this->self)->SetVerticalScroll(::vl::__vwsn::This(this->look)->GetVScroll()); } } @@ -14417,8 +14677,8 @@ Class (::darkskin::ProgressBarTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf135_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf134_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { @@ -14561,40 +14821,40 @@ Class (::darkskin::RadioButtonTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf135_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf136_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf137_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf138_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf139_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf140_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf141_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf142_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } } RadioButtonTemplateConstructor::RadioButtonTemplateConstructor() @@ -14665,13 +14925,13 @@ Class (::darkskin::RightScrollButtonTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf143_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf142_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf144_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf143_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -14704,15 +14964,6 @@ Class (::darkskin::ScrollViewTemplateConstructor) void ScrollViewTemplateConstructor::__vwsn_initialize_instance_(::darkskin::ScrollViewTemplate* __vwsn_this_) { (this->self = __vwsn_this_); - { - ::vl::__vwsn::This(this->self)->SetDefaultScrollSize(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false))); - } - { - ::vl::__vwsn::This(this->self)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf145_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf146_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__(this))); - } { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } @@ -14740,9 +14991,31 @@ Class (::darkskin::ScrollViewTemplateConstructor) { ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_2)); } + (this->look = new ::vl::presentation::templates::GuiCommonScrollViewLook(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false)))); + { + ::vl::__vwsn::This(this->look)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf144_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__(this))); + } + { + ::vl::__vwsn::This(this->look)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf145_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__(this))); + } + { + ::vl::__vwsn::This(this->look)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_1)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->look)); + } { ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); } + { + ::vl::__vwsn::This(this->self)->SetContainerComposition(::vl::__vwsn::This(this->look)->GetContainerComposition()); + } + { + ::vl::__vwsn::This(this->self)->SetHorizontalScroll(::vl::__vwsn::This(this->look)->GetHScroll()); + } + { + ::vl::__vwsn::This(this->self)->SetVerticalScroll(::vl::__vwsn::This(this->look)->GetVScroll()); + } } ScrollViewTemplateConstructor::ScrollViewTemplateConstructor() @@ -14818,20 +15091,20 @@ Class (::darkskin::ShortcutKeyTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf146_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf147_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf148_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf149_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } } ShortcutKeyTemplateConstructor::ShortcutKeyTemplateConstructor() @@ -14959,25 +15232,25 @@ Class (::darkskin::TabHeaderButtonTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf149_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf150_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf151_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf152_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf153_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } } TabHeaderButtonTemplateConstructor::TabHeaderButtonTemplateConstructor() @@ -15023,28 +15296,28 @@ Class (::darkskin::TabHeaderTemplateConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf153_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_0)->GetBoundsComposition())); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf155_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf156_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf158_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_0)->Clicked, __vwsn_event_handler_); } } @@ -15126,7 +15399,7 @@ Class (::darkskin::TabTemplateConstructor) } (this->header = new ::vl::presentation::compositions::GuiRepeatFlowComposition()); { - ::vl::__vwsn::This(this->header)->SetItemTemplate(LAMBDA(::vl_workflow_global::__vwsnf159_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->header)->SetItemTemplate(LAMBDA(::vl_workflow_global::__vwsnf158_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->header)->SetExtraMargin([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(2); __vwsn_temp__.top = static_cast<::vl::vint>(2); __vwsn_temp__.right = static_cast<::vl::vint>(2); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); @@ -15185,23 +15458,23 @@ Class (::darkskin::TabTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf160_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf159_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf161_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf160_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->header)->ItemInserted, __vwsn_event_handler_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf162_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf161_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->header)->ItemRemoved, __vwsn_event_handler_); } { ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf163_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf162_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->self)->SelectedTabPageChanged, __vwsn_event_handler_); } } @@ -15259,22 +15532,13 @@ Class (::darkskin::TextListTemplateConstructor) { (this->self = __vwsn_this_); { - ::vl::__vwsn::This(this->self)->SetRadioBulletTemplate(LAMBDA(::vl_workflow_global::__vwsnf164_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetRadioBulletTemplate(LAMBDA(::vl_workflow_global::__vwsnf163_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->SetCheckBulletTemplate(LAMBDA(::vl_workflow_global::__vwsnf165_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetCheckBulletTemplate(LAMBDA(::vl_workflow_global::__vwsnf164_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->SetBackgroundTemplate(LAMBDA(::vl_workflow_global::__vwsnf166_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetDefaultScrollSize(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false))); - } - { - ::vl::__vwsn::This(this->self)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf167_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf168_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetBackgroundTemplate(LAMBDA(::vl_workflow_global::__vwsnf165_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->self)->SetTextColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#F1F1F1", false))); @@ -15289,28 +15553,47 @@ Class (::darkskin::TextListTemplateConstructor) { ::vl::__vwsn::This(this->self)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_0)); } - (this->container = new ::vl::presentation::compositions::GuiBoundsComposition()); + (this->__vwsn_precompile_1 = new ::vl::presentation::compositions::GuiBoundsComposition()); { - ::vl::__vwsn::This(this->container)->SetInternalMargin([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(1); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetInternalMargin([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(1); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->container)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->container)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } - (this->__vwsn_precompile_1 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBorderElement>())); + (this->__vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBorderElement>())); { - ::vl::__vwsn::This(this->__vwsn_precompile_1.Obj())->SetColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#3F3F46", false))); + ::vl::__vwsn::This(this->__vwsn_precompile_2.Obj())->SetColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#3F3F46", false))); } { - ::vl::__vwsn::This(this->container)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_1)); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_2)); + } + (this->look = new ::vl::presentation::templates::GuiCommonScrollViewLook(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false)))); + { + ::vl::__vwsn::This(this->look)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf166_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + ::vl::__vwsn::This(this->look)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf167_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + ::vl::__vwsn::This(this->look)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_1)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->look)); + } + { + ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); + } + { + ::vl::__vwsn::This(this->self)->SetContainerComposition(::vl::__vwsn::This(this->look)->GetContainerComposition()); + } + { + ::vl::__vwsn::This(this->self)->SetHorizontalScroll(::vl::__vwsn::This(this->look)->GetHScroll()); + } + { + ::vl::__vwsn::This(this->self)->SetVerticalScroll(::vl::__vwsn::This(this->look)->GetVScroll()); } } @@ -15389,20 +15672,20 @@ Class (::darkskin::ToolstripSplitArrowTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf168_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf169_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf170_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf171_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } } ToolstripSplitArrowTemplateConstructor::ToolstripSplitArrowTemplateConstructor() @@ -15434,7 +15717,7 @@ Class (::darkskin::ToolstripButtonTemplateConstructor) { (this->self = __vwsn_this_); { - ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf172_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf171_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); @@ -15482,30 +15765,30 @@ Class (::darkskin::ToolstripButtonTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_2)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf172_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf173_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf174_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf175_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf176_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf177_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } { ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); } @@ -15540,7 +15823,7 @@ Class (::darkskin::ToolstripDropdownButtonTemplateConstructor) { (this->self = __vwsn_this_); { - ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf178_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf177_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); @@ -15631,45 +15914,45 @@ Class (::darkskin::ToolstripDropdownButtonTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_5)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf178_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf179_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf180_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf181_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf182_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf183_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf184_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf185_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf186_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } { ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); } @@ -15767,7 +16050,7 @@ Class (::darkskin::ToolstripSplitButtonTemplateConstructor) { (this->self = __vwsn_this_); { - ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf187_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetSubMenuTemplate(LAMBDA(::vl_workflow_global::__vwsnf186_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); @@ -15843,7 +16126,7 @@ Class (::darkskin::ToolstripSplitButtonTemplateConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_8)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->buttonArrow)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf188_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->buttonArrow)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf187_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->__vwsn_precompile_5)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->buttonArrow)->GetBoundsComposition())); @@ -15852,40 +16135,40 @@ Class (::darkskin::ToolstripSplitButtonTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_5)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf188_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf189_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf190_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf191_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf192_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf193_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf194_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf195_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } { ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); } @@ -16138,13 +16421,13 @@ Class (::darkskin::TopScrollButtonTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf196_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf195_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf197_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf196_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -16178,19 +16461,10 @@ Class (::darkskin::TreeViewTemplateConstructor) { (this->self = __vwsn_this_); { - ::vl::__vwsn::This(this->self)->SetExpandingDecoratorTemplate(LAMBDA(::vl_workflow_global::__vwsnf198_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetExpandingDecoratorTemplate(LAMBDA(::vl_workflow_global::__vwsnf197_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->SetBackgroundTemplate(LAMBDA(::vl_workflow_global::__vwsnf199_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetDefaultScrollSize(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false))); - } - { - ::vl::__vwsn::This(this->self)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf200_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->self)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf201_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetBackgroundTemplate(LAMBDA(::vl_workflow_global::__vwsnf198_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->self)->SetTextColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#F1F1F1", false))); @@ -16205,28 +16479,47 @@ Class (::darkskin::TreeViewTemplateConstructor) { ::vl::__vwsn::This(this->self)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_0)); } - (this->container = new ::vl::presentation::compositions::GuiBoundsComposition()); + (this->__vwsn_precompile_1 = new ::vl::presentation::compositions::GuiBoundsComposition()); { - ::vl::__vwsn::This(this->container)->SetInternalMargin([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(1); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetInternalMargin([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(1); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->container)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->container)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } - (this->__vwsn_precompile_1 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBorderElement>())); + (this->__vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBorderElement>())); { - ::vl::__vwsn::This(this->__vwsn_precompile_1.Obj())->SetColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#3F3F46", false))); + ::vl::__vwsn::This(this->__vwsn_precompile_2.Obj())->SetColor(::vl::__vwsn::Parse<::vl::presentation::Color>(::vl::WString(L"#3F3F46", false))); } { - ::vl::__vwsn::This(this->container)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_1)); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetOwnedElement(::vl::Ptr<::vl::presentation::elements::IGuiGraphicsElement>(this->__vwsn_precompile_2)); + } + (this->look = new ::vl::presentation::templates::GuiCommonScrollViewLook(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false)))); + { + ::vl::__vwsn::This(this->look)->SetVScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf199_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + ::vl::__vwsn::This(this->look)->SetHScrollTemplate(LAMBDA(::vl_workflow_global::__vwsnf200_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->container)); + ::vl::__vwsn::This(this->look)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_1)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->look)); + } + { + ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); + } + { + ::vl::__vwsn::This(this->self)->SetContainerComposition(::vl::__vwsn::This(this->look)->GetContainerComposition()); + } + { + ::vl::__vwsn::This(this->self)->SetHorizontalScroll(::vl::__vwsn::This(this->look)->GetHScroll()); + } + { + ::vl::__vwsn::This(this->self)->SetVerticalScroll(::vl::__vwsn::This(this->look)->GetVScroll()); } } @@ -16276,8 +16569,8 @@ Class (::darkskin::VScrollHandleTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf202_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf201_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -16313,15 +16606,9 @@ Class (::darkskin::VScrollTemplateConstructor) { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } - (this->invalidContainer = new ::vl::presentation::compositions::GuiBoundsComposition()); + (this->behavior = new ::vl::presentation::templates::GuiCommonScrollBehavior()); { - ::vl::__vwsn::This(this->invalidContainer)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); - } - { - ::vl::__vwsn::This(this->invalidContainer)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); - } - { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->invalidContainer)); + ::vl::__vwsn::This(this->self)->AddComponent(static_cast<::vl::presentation::controls::GuiComponent*>(this->behavior)); } (this->__vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBackgroundElement>())); { @@ -16341,31 +16628,55 @@ Class (::darkskin::VScrollTemplateConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_1)->SetDirection(::vl::presentation::compositions::GuiSideAlignedComposition::Direction::Top); } { - (this->__vwsn_precompile_2 = new ::vl::presentation::controls::GuiButton(::vl::presentation::theme::ThemeName::Button)); + (this->buttonDecrease = new ::vl::presentation::controls::GuiButton(::vl::presentation::theme::ThemeName::Button)); } - (this->__vwsn_precompile_3 = ::vl::__vwsn::This(this->__vwsn_precompile_2)->GetBoundsComposition()); + (this->__vwsn_precompile_2 = ::vl::__vwsn::This(this->buttonDecrease)->GetBoundsComposition()); { - ::vl::__vwsn::This(this->__vwsn_precompile_3)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_2)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->__vwsn_precompile_2)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf203_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->buttonDecrease)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf202_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->__vwsn_precompile_1)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_2)->GetBoundsComposition())); + ::vl::__vwsn::This(this->__vwsn_precompile_1)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->buttonDecrease)->GetBoundsComposition())); } { ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); } - (this->__vwsn_precompile_4 = new ::vl::presentation::compositions::GuiSideAlignedComposition()); + (this->__vwsn_precompile_3 = new ::vl::presentation::compositions::GuiSideAlignedComposition()); { - ::vl::__vwsn::This(this->__vwsn_precompile_4)->SetMaxRatio(::vl::__vwsn::Parse(::vl::WString(L"0.5", false))); + ::vl::__vwsn::This(this->__vwsn_precompile_3)->SetMaxRatio(::vl::__vwsn::Parse(::vl::WString(L"0.5", false))); } { - ::vl::__vwsn::This(this->__vwsn_precompile_4)->SetMaxLength(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false))); + ::vl::__vwsn::This(this->__vwsn_precompile_3)->SetMaxLength(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"20", false))); } { - ::vl::__vwsn::This(this->__vwsn_precompile_4)->SetDirection(::vl::presentation::compositions::GuiSideAlignedComposition::Direction::Bottom); + ::vl::__vwsn::This(this->__vwsn_precompile_3)->SetDirection(::vl::presentation::compositions::GuiSideAlignedComposition::Direction::Bottom); } + { + (this->buttonIncrease = new ::vl::presentation::controls::GuiButton(::vl::presentation::theme::ThemeName::Button)); + } + (this->__vwsn_precompile_4 = ::vl::__vwsn::This(this->buttonIncrease)->GetBoundsComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_4)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->buttonIncrease)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf203_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this))); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_3)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->buttonIncrease)->GetBoundsComposition())); + } + { + ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_3)); + } + (this->handleContainer = new ::vl::presentation::compositions::GuiBoundsComposition()); + { + ::vl::__vwsn::This(this->handleContainer)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(20); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(20); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->handleContainer)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::NoLimit); + } + (this->handle = new ::vl::presentation::compositions::GuiPartialViewComposition()); { (this->__vwsn_precompile_5 = new ::vl::presentation::controls::GuiButton(::vl::presentation::theme::ThemeName::Button)); } @@ -16377,45 +16688,7 @@ Class (::darkskin::VScrollTemplateConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_5)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf204_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->__vwsn_precompile_4)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_5)->GetBoundsComposition())); - } - { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_4)); - } - (this->handleContainer = new ::vl::presentation::compositions::GuiBoundsComposition()); - { - ::vl::__vwsn::This(this->handleContainer)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(20); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(20); return __vwsn_temp__; }()); - } - { - ::vl::__vwsn::This(this->handleContainer)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::NoLimit); - } - (this->__vwsn_precompile_7 = new ::vl::presentation::compositions::GuiBoundsComposition()); - { - ::vl::__vwsn::This(this->__vwsn_precompile_7)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); - } - { - ::vl::__vwsn::This(this->handleContainer)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_7)); - } - (this->__vwsn_precompile_8 = new ::vl::presentation::compositions::GuiBoundsComposition()); - { - ::vl::__vwsn::This(this->__vwsn_precompile_8)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); - } - { - ::vl::__vwsn::This(this->handleContainer)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_8)); - } - (this->handle = new ::vl::presentation::compositions::GuiPartialViewComposition()); - { - (this->__vwsn_precompile_9 = new ::vl::presentation::controls::GuiButton(::vl::presentation::theme::ThemeName::Button)); - } - (this->__vwsn_precompile_10 = ::vl::__vwsn::This(this->__vwsn_precompile_9)->GetBoundsComposition()); - { - ::vl::__vwsn::This(this->__vwsn_precompile_10)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); - } - { - ::vl::__vwsn::This(this->__vwsn_precompile_9)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf205_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this))); - } - { - ::vl::__vwsn::This(this->handle)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_9)->GetBoundsComposition())); + ::vl::__vwsn::This(this->handle)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_5)->GetBoundsComposition())); } { ::vl::__vwsn::This(this->handleContainer)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->handle)); @@ -16424,56 +16697,15 @@ Class (::darkskin::VScrollTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->handleContainer)); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf206_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_2)->Clicked, __vwsn_event_handler_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf207_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_5)->Clicked, __vwsn_event_handler_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf208_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf205_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf209_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_7)->GetEventReceiver()->leftButtonDown, __vwsn_event_handler_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf210_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf206_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf211_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_8)->GetEventReceiver()->leftButtonDown, __vwsn_event_handler_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf212_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf213_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf214_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->leftButtonDown, __vwsn_event_handler_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf215_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->leftButtonUp, __vwsn_event_handler_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf216_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->mouseMove, __vwsn_event_handler_); - } - { - ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->invalidContainer)); - } } VScrollTemplateConstructor::VScrollTemplateConstructor() @@ -16490,6 +16722,15 @@ Class (::darkskin::VScrollTemplate) auto __vwsn_resolver_ = ::vl::Ptr<::vl::presentation::GuiResourcePathResolver>(new ::vl::presentation::GuiResourcePathResolver(__vwsn_resource_, ::vl::__vwsn::This(__vwsn_resource_.Obj())->GetWorkingDirectory())); ::vl::__vwsn::This(this)->SetResourceResolver(__vwsn_resolver_); ::vl::__vwsn::This(this)->__vwsn_initialize_instance_(this); + this->__vwsn_instance_ctor_(); + } + + void VScrollTemplate::__vwsn_instance_ctor_() + { + ::vl::__vwsn::This(this->behavior)->AttachScrollTemplate(static_cast<::vl::presentation::templates::GuiScrollTemplate*>(this->self)); + ::vl::__vwsn::This(this->behavior)->AttachDecreaseButton(this->buttonDecrease); + ::vl::__vwsn::This(this->behavior)->AttachIncreaseButton(this->buttonIncrease); + ::vl::__vwsn::This(this->behavior)->AttachVerticalPartialView(this->handle); } VScrollTemplate::~VScrollTemplate() @@ -16507,15 +16748,9 @@ Class (::darkskin::VTrackerTemplateConstructor) { ::vl::__vwsn::This(this->self)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); } - (this->invalidContainer = new ::vl::presentation::compositions::GuiBoundsComposition()); + (this->behavior = new ::vl::presentation::templates::GuiCommonScrollBehavior()); { - ::vl::__vwsn::This(this->invalidContainer)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); - } - { - ::vl::__vwsn::This(this->invalidContainer)->SetMinSizeLimitation(::vl::presentation::compositions::GuiGraphicsComposition::MinSizeLimitation::LimitToElementAndChildren); - } - { - ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->invalidContainer)); + ::vl::__vwsn::This(this->self)->AddComponent(static_cast<::vl::presentation::controls::GuiComponent*>(this->behavior)); } (this->__vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(::vl::reflection::description::Element_Constructor<::vl::presentation::elements::GuiSolidBackgroundElement>())); { @@ -16587,7 +16822,7 @@ Class (::darkskin::VTrackerTemplateConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_7)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->__vwsn_precompile_6)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf217_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->__vwsn_precompile_6)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf207_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->handle)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_6)->GetBoundsComposition())); @@ -16599,25 +16834,10 @@ Class (::darkskin::VTrackerTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf218_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf208_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf219_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->leftButtonDown, __vwsn_event_handler_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf220_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->leftButtonUp, __vwsn_event_handler_); - } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf221_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->handle)->GetEventReceiver()->mouseMove, __vwsn_event_handler_); - } - { - ::vl::__vwsn::This(this->self)->SetContainerComposition(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->invalidContainer)); - } } VTrackerTemplateConstructor::VTrackerTemplateConstructor() @@ -16634,6 +16854,13 @@ Class (::darkskin::VTrackerTemplate) auto __vwsn_resolver_ = ::vl::Ptr<::vl::presentation::GuiResourcePathResolver>(new ::vl::presentation::GuiResourcePathResolver(__vwsn_resource_, ::vl::__vwsn::This(__vwsn_resource_.Obj())->GetWorkingDirectory())); ::vl::__vwsn::This(this)->SetResourceResolver(__vwsn_resolver_); ::vl::__vwsn::This(this)->__vwsn_initialize_instance_(this); + this->__vwsn_instance_ctor_(); + } + + void VTrackerTemplate::__vwsn_instance_ctor_() + { + ::vl::__vwsn::This(this->behavior)->AttachScrollTemplate(static_cast<::vl::presentation::templates::GuiScrollTemplate*>(this->self)); + ::vl::__vwsn::This(this->behavior)->AttachVerticalTrackerHandle(this->handle); } VTrackerTemplate::~VTrackerTemplate() @@ -16649,7 +16876,7 @@ Class (::darkskin::WindowTemplateConstructor) { (this->self = __vwsn_this_); { - ::vl::__vwsn::This(this->self)->SetTooltipTemplate(LAMBDA(::vl_workflow_global::__vwsnf222_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->self)->SetTooltipTemplate(LAMBDA(::vl_workflow_global::__vwsnf209_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->self)->SetCustomizedBorder(::vl::__vwsn::Parse(::vl::WString(L"true", false))); @@ -16817,7 +17044,7 @@ Class (::darkskin::WindowTemplateConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_13)->SetText(::vl::WString(L" 0 ", false)); } { - ::vl::__vwsn::This(this->__vwsn_precompile_13)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf223_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->__vwsn_precompile_13)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf210_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->__vwsn_precompile_12)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_13)->GetBoundsComposition())); @@ -16843,7 +17070,7 @@ Class (::darkskin::WindowTemplateConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_17)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(1); __vwsn_temp__.top = static_cast<::vl::vint>(1); __vwsn_temp__.right = static_cast<::vl::vint>(1); __vwsn_temp__.bottom = static_cast<::vl::vint>(1); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->__vwsn_precompile_16)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf224_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->__vwsn_precompile_16)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf211_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->__vwsn_precompile_15)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_16)->GetBoundsComposition())); @@ -16872,7 +17099,7 @@ Class (::darkskin::WindowTemplateConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_19)->SetText(::vl::WString(L" r ", false)); } { - ::vl::__vwsn::This(this->__vwsn_precompile_19)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf225_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->__vwsn_precompile_19)->SetControlTemplate(LAMBDA(::vl_workflow_global::__vwsnf212_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->__vwsn_precompile_18)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_19)->GetBoundsComposition())); @@ -16937,13 +17164,13 @@ Class (::darkskin::WindowTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_1)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf226_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf213_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf227_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf214_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { @@ -16972,42 +17199,7 @@ Class (::darkskin::WindowTemplate) this->FinalizeInstanceRecursively(static_cast<::vl::presentation::templates::GuiTemplate*>(this)); } -/*********************************************************************** -Class (::ScrollTemplateScript) -***********************************************************************/ - } -void ScrollTemplateScript::SetScroll(::vl::vint totalPixels, ::vl::vint newOffset, ::vl::presentation::templates::GuiScrollTemplate* scrollTemplate) -{ - auto totalSize = ::vl::__vwsn::This(scrollTemplate)->GetTotalSize(); - auto ratio = (static_cast(newOffset) / static_cast(totalPixels)); - auto newPosition = static_cast<::vl::vint>(::vl::reflection::description::Math::Round((ratio * static_cast(totalSize)))); - auto offset1 = static_cast<::vl::vint>(::vl::reflection::description::Math::Round(((static_cast(newPosition) / static_cast(totalSize)) * static_cast(totalPixels)))); - auto offset2 = static_cast<::vl::vint>(::vl::reflection::description::Math::Round(((static_cast((newPosition + static_cast<::vl::vint>(1))) / static_cast(totalSize)) * static_cast(totalPixels)))); - auto delta1 = (offset1 - newOffset); - auto delta2 = (offset2 - newOffset); - if ((delta1 < static_cast<::vl::vint>(0))) - { - (delta1 = (- delta1)); - } - if ((delta2 < static_cast<::vl::vint>(0))) - { - (delta2 = (- delta2)); - } - if ((delta1 < delta2)) - { - ::vl::__vwsn::This(::vl::__vwsn::This(scrollTemplate)->GetCommands())->SetPosition(newPosition); - } - else - { - ::vl::__vwsn::This(::vl::__vwsn::This(scrollTemplate)->GetCommands())->SetPosition((newPosition + static_cast<::vl::vint>(1))); - } -} - -ScrollTemplateScript::ScrollTemplateScript() -{ -} - #undef GLOBAL_SYMBOL #undef GLOBAL_NAME #undef GLOBAL_OBJ @@ -17039,9 +17231,9 @@ namespace vl class DarkSkinResourceReader { public: - static const vint parserBufferLength = 1285; // 2953 bytes before compressing + static const vint parserBufferLength = 1281; // 2935 bytes before compressing static const vint parserBufferBlock = 1024; - static const vint parserBufferRemain = 261; + static const vint parserBufferRemain = 257; static const vint parserBufferRows = 2; static const char* parserBuffer[2]; @@ -17052,8 +17244,8 @@ namespace vl }; const char* DarkSkinResourceReader::parserBuffer[] = { - "\x89\x0B\x00\x00\xFD\x04\x00\x00\x06\x00\x01\x82\x80\x03\x03\x82\x81\x82\x01\xC4\x2F\x23\x38\x06\x81\x81\x86\x01\xC9\x2E\x33\x34\x39\x32\x37\x31\x65\x00\x8E\x9A\x80\x03\x2B\x30\x39\x69\x70\x34\x2D\x0E\x80\x00\x93\x88\x13\x95\x97\x85\x33\x2C\x39\x3C\x36\x65\x04\x25\x92\x91\x84\x29\x32\x3C\x74\x0F\x25\x9A\x91\x83\x20\x37\x30\x73\x73\x0E\x21\x3D\x35\x32\x29\x32\x63\x6F\x32\x24\x35\x94\x81\x92\x88\x06\xD0\x84\x21\x32\x3B\x37\x29\x35\x69\x6E\x01\x0D\xA5\x90\x09\xAE\x81\x42\x40\xA5\x2C\x39\xAD\x32\x85\x31\x75\x45\xAE\x34\x3E\x5D\x91\xB7\x80\x3C\x67\xBE\x1C\x13\x27\x37\xB5\x32\x6B\xAF\x33\xAD\x9F\x95\x33\x39\xBD\x2E\xB0\xA0\x0E\x34\xA5\x31\x1E\x11\x23\x44\x25\x26\x31\x35\x38\x36\x3A\x2D\x4F\x36\x25\x32\x38\x90\x33\x32\x22\x73\x89\xAC\x3A\xA6\x1F\x10\x23\xA0\xA1\xFC\x0F\x1B\xCD\xCF\xD0\xBE\x30\x80\xFD\xA3\xC5\xC7\xC3\x11\x29\x63\xC8\xB4\x29\x36\xB9\xCB\xC9\xCA\x69\x17\xD9\xDC\x15\xD2\x3A\xCF\xD0\xA2\xA4\xEF\x3C\xCE\xDC\x1E\x31\x35\xBD\x9E\xF0\x10\x17\x19\x23\x21\x21\xA3\xC7\xC9\xE7\xD1\xC5\x33\xB9\x17\xA8\xFE\x97\xF2\xBD\xA4\x05\x92\xEF\x01\xC7\x21\x23\x37\x20\xBD\xBA\x37\x66\x69\x27\x2D\xAB\xAE\x84\x84\x83\xEF\xC3\x30\x30\x35\x03\x99\x93\x93\x06\xF8\xF2\xF0\x35\xBD\x34\x38\x39\x7E\x73\x15\x18\x19\x14\x25\x45\x81\x42\x54\x56\x58\x56\x1B\x47\x73\x1F\x19\x1D\x72\x18\x4E\x0B\x18\xF3\x74\x46\x42\x85\x03\x56\x83\x51\x51\x50\x43\x42\x55\x82\x57\x59\x58\x86\x40\xF8\x43\x48\x7E\x13\x4A\x6D\x11\x18\x1B\x12\x63\x1C\x19\x1D\x97\x5E\x5E\x42\x8C\x00\x2E\x0E\x0B\x0B\x36\xB8\x87\x8E\x78\x63\x15\x19\x12\x0B\x68\x23\x81\x41\x04\x25\x44\x91\x43\x51\x66\x30\x43\x1B\x6C\x76\x6D\x8F\x8B\x65\x39\x25\x41\x95\x40\x39\x95\x97\x8C\x92\x4A\x8C\x9E\x1B\x0B\x54\x39\x10\x1E\x59\x7E\x5F\x41\x48\x1D\x4A\x73\x1F\x0B\x11\x75\x29\x18\x96\x6C\xB4\x6E\x10\x17\x8B\x67\x19\x50\x92\x90\x00\x20\x76\x42\x9D\x53\x0F\x81\x85\x19\x46\x03\x77\x66\x1C\x1C\x43\x4C\x45\x9E\x10\x98\x4D\x53\x02\x25\x48\xA1\x40\x14\x00\x89\x5E\x7D\x1A\x30\x64\x1D\x7A\x41\xF5\x4E\x4C\x4E\x41\x97\xBE\x40\x52\x50\x85\x47\x59\x53\x52\x31\x25\x44\x0A\xA8\x02\x64\x19\x83\x1C\x0B\xBA\x0A\x0E\x10\x6F\x34\x14\x99\x1B\x1E\x72\x13\x70\x1B\x42\x35\x1E\xAA\x5D\x36\x7E\x7F\x4C\x1D\x65\x18\x05\x4A\xAF\x01\x66\xA5\x54\xAA\x59\x6A\xA5\xAF\xAD\x6E\x39\xA0\x1F\xAE\x65\x1A\x05\x4A\xB3\xC1\xA7\xA9\xAA\x0E\x43\x28\x18\x53\x1A\xAC\xB8\x1A\xB0\xB3\x25\x25\x4D\xB5\xB4\xC3\x93\xB5\xB7\xB5\x49\x3C\xAD\x19\x58\x63\x2B\x17\x1A\xAC\x75\x2E\x14\x1B\xB6\x61\x3C\xA0\xB6\x41\xF3\x82\xBB\x18\xB1\x6E\x2A\xAD\x7E\x18\x6F\x19\xB0\xBC\xAF\x1F\x25\x41\xC0\xB8\xF7\xA2\xB5\x1C\x45\x6F\x2D\x17\x78\x1D\xB2\xAC\x1F\xBD\x19\x97\x83\x47\xA6\xBD\xF8\xAA\xA4\x16\xB5\x45\x5C\x05\x4A\xC6\x04\xD5\xCA\x0F\x54\xBC\x90\x19\x19\xBA\x94\x4F\xC3\xC2\x41\x27\xD4\xC3\xB7\x59\x69\x78\x54\x1C\x13\x61\x22\x13\x5B\xC3\x21\x25\x45\xCD\xC7\x2B\xCB\x4D\xCB\x5A\x36\x78\x4E\xBD\x19\xBA\xB1\xB5\x18\x08\x25\x44\xD8\xCD\xB1\x1F\xFA\xCA\x58\x1D\x56\x29\x15\x1B\x1D\x25\xC0\xDB\xB2\xD0\xA3\x8E\x45\xD4\x00\x2A\xC8\xD5\x10\x1E\x70\x16\x44\x19\x56\x67\x0A\x6F\xA5\xBC\x4A\x4F\xC3\xBF\x40\xF5\x92\xB8\xD3\x11\xEC\xB0\x1F\xCD\xD0\x00\xC2\xC5\xAA\xDA\xF9\xBA\x08\x11\xAC\xB3\x88\x1E\xD4\x4C\x0F\xD9\x05\x4A\xDF\x47\xF5\xD7\xDF\x47\xB3\xA6\xDF\xB3\xDC\xE1\x88\xD8\x10\x15\x72\x23\x7B\x19\xD4\x70\xC3\xD5\xD0\xE2\x05\xC8\xD5\xB8\xD0\xE8\xAA\xBC\xBA\xBB\x0F\xD7\x05\x4A\xE7\x81\xEA\xA0\xCE\xCC\x0E\xD2\xDC\xB2\x08\x25\x68\xE1\xEA\x0E\x4C\x0B\x64\x1C\xDE\x6C\x34\xA6\xAC\x99\xC9\xA6\xE2\xD2\x09\x25\x78\xEB\xE8\x13\x69\x14\x4D\xD3\xD3\x75\x6F\x8D\x1A\x1B\x48\x25\x11\x1B\x9F\x86\xCE\x49\xD9\xE2\x75\xFC\xEE\xEE\xD3\x77\x26\xC2\xDF\xEA\x4D\x38\x55\x1D\x58\x72\x07\xB4\xEF\xC3\x46\xC6\x4D\xF5\xD6\x75\xD5\xFE\x19\x1D\x97\xE7\xB3\xEC\xAE\xB6\xFC\xAE\x05\x49\xEB\xD4\xF6\xF7\x14\xCB\xA9\x1E\xA8\xE4\x53\xFC\xAA\xEA\x41\xF7\xE0\xFA\xA9\x13\x8E\x73\x64\x5A\x1B\x65\x1D\x64\x1D\x6F\x65\x7F\x32\x1D\x05\x24\x07\x8B\x74\xA3\x6F\x0B\x5D\x00\x58\x7F\x61\x09\x86\x21\x04\xFA\x7A\x06\x29\x07\x7C\x36\xDA\x68\x7D\xE4\x23\x05\x24\x0E\xAB\x72\x0A\xEA\x28\x0F\xEB\x04\x71\x77\x0C\xB5\x71\x72\x1C\x66\x21\x0A\x94\x80\x76\x36\x3F\x71\x7A\xE9\x66\x80\x02\x94\x7E\x63\x29\x28\x0A\x29\x74\x08\x2C\x1D\x4B\x05\x0D\x3C\x0F\x66", - "\x83\x06\x20\x88\x0B\xE0\x60\x27\xFF\x41\x87\x26\x03\x8F\x0E\xB6\x31\x87\x66\x83\x0D\x8C\x82\x54\x11\x65\xF1\x47\x74\x32\x13\x8F\x63\x03\x25\x38\x8B\xEA\x51\x82\x0D\x29\x88\x79\x86\x15\x05\x25\x18\xDB\x81\x67\xE4\x74\x5C\x86\xD3\x42\x82\xF3\x74\x0F\x61\x6F\x46\x26\x8D\x50\x8F\x0F\x70\x14\x20\x24\x38\x30\x7C\x2C\x74\x01\x09\x65\x6F\x00\x87\xC8\x4D\x8B\x20\x4F\x94\x6E\xC5\x72\x8C\x0C\x3A\xA1\x26\x8A\x31\x89\x05\x49\x0A\x9B\x8A\x42\x86\x90\x0E\x44\x12\x54\x1C\x64\x0C\x8E\x37\x08\x91\x72\x27\x63\x21\xCA\x02\x9A\x06\x2A\x0E\x94\x61\x21\x22\x7D\x1D\x0F\x6A\x76\x83\x25\x91\x8E\x73\x80\x96\x1D\xF1\x73\x81\xF3\x67\x85\x80\x40\x83\x22\x10\x9C\x9E\x93\x54\xB5\x8F\x8E\xF2\x7C\x56\x1C\x57\x89\x8A\x34\x88\x6D\x96\x85\x8A\x95\xDF\x7F\x6E\x97\xBA\x40\x9B\x36\x70\x14\x66\xCD\x45\x93\x90\x3B\xA4\x82\x76\xC8\x46\x8C\xDA\x4C\x9D\x92\x00\x65\x0F\x85\xD2\x6E\x23\x26\xCC\x7A\x54\x2B\x2D\x82\x6F\xEE\x5C\x6D\x0C\x80\x76\x20\x72\x94\x86\x9B\xCF\x92\x9A\x40\x4B\x75\x73\xBA\x56\x0C\x71\x8E\x74\x7C\xB3\x40\x56\x20\x7A\x94\x87\x0A\x59\x34\x91\x1F\x85\x8D\x28", + "\x77\x0B\x00\x00\xF9\x04\x00\x00\x05\x00\x01\x82\x80\x03\x03\x82\x81\x82\x01\xC4\x2F\x23\x38\x06\x81\x81\x86\x01\xC9\x2E\x33\x34\x39\x32\x37\x31\x65\x0D\x0E\x80\x0A\x89\x8B\x89\x8A\x17\xE5\x13\x34\x39\x3C\x35\x32\x02\x1B\xA8\x81\x94\x25\x30\x3C\x3B\x07\x1B\xB0\x81\x83\x2C\x31\x33\x39\x39\x4E\x61\x2D\x25\x32\x2D\x33\x31\x37\x72\x64\x1B\x84\x8B\x88\x8A\x82\xA3\x44\x61\x32\x2B\x33\x2B\x35\x34\x37\x01\x43\x9B\x90\x03\xAA\x82\x20\x9B\x65\x6C\x0F\xA5\x3A\x83\x31\x3B\x9D\x6E\x74\x3E\x5B\x83\xB1\x80\x1F\xAE\x3E\x3C\x03\x2F\x31\xB5\x31\xB1\x17\x69\xA3\xA5\x85\x33\x39\xB8\x92\x93\x20\x6E\x3A\x85\x3D\x1A\x13\x10\x22\x65\x66\x21\x35\x3C\x34\x39\x17\x27\x76\x65\x32\x32\x39\x34\x31\x32\x11\x69\xBF\xAC\x20\xAE\x1B\x12\x23\xCB\x98\xBC\x2F\x12\xC4\xCA\xCE\xB8\x93\x76\xF3\xB9\xBB\xBD\xBB\x13\x29\xAC\x3E\xF4\x29\x2C\xB7\xC1\xC7\xC5\xC6\x8F\x91\xEF\x33\xC2\x3D\xC8\xCD\xCC\x9B\xB3\xDD\xC2\x3B\x34\xCD\xDB\x11\x30\x30\x37\x01\x23\x23\x22\xCC\xDE\xBE\xE9\xAF\x1F\xC5\x32\xE4\xE7\xBA\x9A\xE8\x83\xAC\x0B\x8C\xE9\x81\x23\x61\x63\x07\x2E\xBB\xB6\x36\x33\x34\x67\x43\x91\xAE\x88\x86\x81\xF3\x21\x70\x70\x00\x84\xFB\x8D\x8E\x82\xF7\xE8\xF0\x2B\xAD\x30\x3A\x38\xBB\x39\x65\x64\x14\x1B\x8B\xF9\x86\xA4\xA6\x4E\x6E\x1D\x4F\x1C\x6F\x35\x12\x1C\x46\x2E\x23\x19\x79\x79\x03\x6A\x46\x42\x83\x39\x7B\x46\x53\x40\x48\x7F\x7D\x53\x53\x0C\x82\x4E\x7B\x40\xEE\x4E\x10\x51\x1B\x61\x2C\x12\x47\x18\x6C\x35\x1E\x60\x55\x0E\x68\x80\x02\x0B\x2E\x2F\x0C\x8A\x8B\x2D\x98\x73\x19\x15\x49\x2E\x08\x19\x86\x01\x51\x0B\x46\x8E\x01\x7D\x46\x1A\x49\x63\x2A\x6C\x5B\x88\x25\x8E\x69\x0F\x46\x47\x81\x4F\x8B\x92\x2D\xBE\x80\x92\x90\x6E\x2F\x04\x15\x1E\x70\x1C\x54\x5F\x18\x8C\x70\x14\x1C\x50\x73\x2F\x07\x11\x1D\x69\x0E\x99\x6B\x6A\x6E\x10\x15\x8B\x19\x4F\x76\x88\x8C\x00\xD6\x46\x4D\x9B\x14\x05\x87\x85\x1A\x11\xB3\x4E\x62\x1E\x01\x1B\x78\x91\x40\x9C\x06\x98\x43\x53\x02\x1B\x40\xA1\x40\x14\xF6\x7F\x44\x7D\x1A\x26\x64\x13\x7B\x83\x31\x4D\xA3\x4D\x4D\x37\x51\x8C\x4E\x4F\x40\x64\x11\x0F\x46\x24\x18\xA2\x40\x19\xFF\x73\x11\x82\x0E\x3A\x02\x1F\x18\x1D\x5B\xAD\x13\x14\x96\xB3\x6C\x12\x11\x1D\xA4\xAC\x5C\x48\x7D\x35\x74\x15\x18\x06\x1B\x74\xA1\x40\xA7\x4B\x5E\xAF\x50\xA8\xAB\xAD\xAE\x1B\xAB\x70\x31\xA5\x1A\x06\x1B\x44\xB7\xAD\xA7\x9F\xBA\x03\x10\x1A\x3E\x6B\x12\xA8\x1E\xC0\x82\xB5\x0B\x46\xD3\x87\xB9\xAD\xB2\xCB\x8D\xB9\x12\xAC\x6D\x17\x53\x1B\x1A\x67\x32\x15\x82\x1B\x64\x11\xB1\x1A\xAC\xC6\x86\x49\xB8\xAE\x6B\x3A\xAE\x18\xA8\xF3\x62\x1F\x1B\xB3\xE6\xB2\xAF\x07\x46\xF7\x96\xBD\xB8\xB6\x75\x14\x4F\x19\x1B\xDD\x74\x12\xB8\x1B\xF5\xA5\x12\x4E\x41\x07\xEC\xBE\xB8\xA8\x54\x0C\xBB\x4C\x07\x1B\x50\xCA\xBF\xC2\x3A\x09\x52\xAC\x14\x69\x1F\xBA\x61\xC1\xF9\x86\x4D\xC6\xC2\xC9\x9D\x5F\x56\x5B\x74\x0C\x11\x1A\x18\x59\x45\xC1\x0B\x46\x2B\xD3\xC1\xCB\x42\x23\xE1\x5C\x4A\x4B\xF4\xA5\x10\xAF\xB9\x65\x20\x0B\x46\xCE\x2E\xFB\xA5\xC4\xCC\x60\x74\x16\x15\x1A\x65\x37\x1B\xC6\xCD\xC1\xB8\xC9\xA6\x43\x4B\xC0\x00\xCA\xCF\x45\x38\x10\x1E\x45\x64\x0F\x57\x18\x60\x3F\x72\x17\xB8\x50\x05\xE9\xB3\x43\xBA\xC8\xBE\xC7\x12\xB8\x75\x30\x15\xCF\xCD\xF6\xB8\xBB\xA5\xD8\xEF\xBA\x08\x13\xA9\x03\xEC\x18\x10\xD5\x26\x45\xC9\x07\x46\x77\xFD\xCD\xDB\xDB\xA8\xAC\x14\xC0\xD2\xC2\x9E\xD2\x40\xD8\xD7\xBE\xC8\x10\x15\x5A\xDA\xC2\x1D\xC1\x3C\xC6\x4D\xE3\xD3\x6D\xDB\xB6\xCE\xB7\xE0\xA4\xD4\xB9\xC1\x17\x1B\x49\xE6\xDE\xA0\xA6\xC8\xCB\xDF\x68\xCF\x6B\x46\x08\x6B\xC5\xED\xD8\x13\x81\x74\x10\xDD\xAA\xBD\x9B\x9F\xAC\xE0\x38\xE6\x0B\x46\xEC\x9C\xFA\x0C\x11\x1A\x14\x43\xD5\xD3\x5A\x25\xAD\x1E\x18\x12\x65\x21\x16\x9D\xD7\xC5\xA5\xEB\xBE\xCF\xB7\xF9\xE4\xD3\x1D\x1C\xEA\xD5\xED\x13\x6E\x75\x17\x56\x1C\xAD\xEE\xA0\xEE\xAC\x8D\xC3\x4F\xE0\xDB\xA0\x90\xFE\x19\x1D\x92\xDD\xBC\xAA\xEB\x05\xDE\x0B\x46\xF9\xCF\xD1\xF3\x15\xB0\x69\x24\xA7\xD1\xE8\xA4\xCE\x41\xFE\xD3\xDC\xFA\x0D\x10\x61\xAA\x5A\x5E\x19\x19\x33\xF4\x17\xD9\xD2\xB2\x5D\x03\x46\x02\x85\x76\x42\x6F\x09\x5C\xF7\x33\x79\xC1\x04\x86\x20\x06\x90\x70\x54\x52\x02\x7B\x6A\x55\x7F\x75\xD0\x63\x03\x23\x17\x95\x76\x14\x60\x38\x0C\xD5\x7D\x6A\x55\xE3\x76\x79\xE8\x12\x66\x20\x12\x8F\x82\x07\xAB\x7E\x6E\xEE\x4C\x77\x7B\x32\x0C\x83\x20\x0E\x95\x7F\x14\x68\x00\x28\x3A\x1E\x2C\x0E\x4B\x05\x0D\x1E\x05\x69\x82\x83\x3D\x87", + "\x84\x53\x16\x6A\x49\x7A\x7C\x7F\x96\x3E\x7F\x0D\xD0\x4D\x85\xCB\x06\x2B\x89\x13\x94\x0F\x64\xC0\x62\x7A\x62\x14\x85\x61\x0D\x1B\x26\x8A\xB5\x6F\x8A\x18\x51\x83\x79\x16\x95\x03\x23\x5F\x99\x8B\xC9\x44\x7E\x20\xC2\x47\x7D\x6D\xFD\x69\x78\x1D\x05\x65\x5A\x83\x2D\x8E\x89\x6F\x13\x34\x45\x59\x4B\x7C\xAD\x34\x09\x08\x8B\x2F\x0C\x0B\xA1\x7B\x89\x81\x0D\x8D\x7E\x54\x11\x8C\x1B\x73\x89\x0C\xB3\x61\x85\x82\x00\x85\x0D\x0A\x1B\x2B\x91\x2C\x82\x94\x90\x70\x04\x0A\xB8\x70\x04\x0C\x3D\xAE\x0C\x8A\x2D\x9D\x63\x40\x1F\x60\x91\x47\x82\x65\x90\xDE\x75\x0D\xC1\x34\x76\x20\x52\xB0\x8A\x8E\x9F\x90\x0D\x1D\xED\x78\x92\x0B\x98\x86\x78\x14\x61\x90\x2A\xF4\x8C\x7C\xF7\x4B\x75\x85\x58\x86\x21\x2E\xA7\x93\x91\x54\xB6\x68\x6F\xB0\x89\x5A\x2C\x85\x35\x90\x95\x6C\x61\x98\x3E\x61\x92\x2A\x9F\x8D\x95\x44\x82\x71\x20\x66\x91\x96\x7D\x65\x0B\x85\xE6\x4E\x24\x93\xA6\x60\x56\x15\x29\x82\x6E\xBA\x45\x89\x74\x79\x66\x21\x38\xA7\x8B\x9B\x0F\xA4\x8A\x5D\xC8\x8D\x6E\x15\x08\x79\x3B\x35\x2F\x79\x91\xB6\x46\x21\x3C\xA7\x87\x0B\xA7\x15\x93\x8F\x89\x83\x28", }; class DarkSkinResourceLoaderPlugin : public Object, public IGuiPlugin diff --git a/Import/Skins/DarkSkin/DarkSkin.h b/Import/Skins/DarkSkin/DarkSkin.h index 54c004c2..bdd79ba8 100644 --- a/Import/Skins/DarkSkin/DarkSkin.h +++ b/Import/Skins/DarkSkin/DarkSkin.h @@ -34,8 +34,8 @@ https://github.com/vczh-libraries namespace vl_workflow_global { - struct __vwsnf100_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf101_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf100_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf101_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf102_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf103_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf104_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; @@ -43,17 +43,17 @@ namespace vl_workflow_global struct __vwsnf106_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf107_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf108_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf109_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf109_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf10_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf110_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf111_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf112_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf113_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf113_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf114_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf115_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf116_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf117_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf118_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf118_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf119_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf11_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf120_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; @@ -69,10 +69,10 @@ namespace vl_workflow_global struct __vwsnf12_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf130_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf131_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf132_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf132_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf133_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf134_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf135_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf134_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf135_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf136_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf137_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf138_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; @@ -80,45 +80,45 @@ namespace vl_workflow_global struct __vwsnf13_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf140_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf141_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf142_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf142_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf143_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf144_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf144_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf145_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf146_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf146_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf147_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf148_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf149_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf149_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf14_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf150_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf151_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf152_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf153_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf153_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf155_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf156_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf158_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf158_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf159_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf15_DarkSkin_darkskin_CheckItemBackgroundTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf160_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf161_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf162_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf163_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf163_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf164_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf165_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf166_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf167_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf168_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf168_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf169_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf16_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf170_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf171_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf171_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf172_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf173_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf174_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf175_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf176_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf177_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf177_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf178_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf179_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf17_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__; @@ -128,7 +128,7 @@ namespace vl_workflow_global struct __vwsnf183_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf184_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf185_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf186_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf186_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf187_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf188_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf189_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; @@ -138,43 +138,30 @@ namespace vl_workflow_global struct __vwsnf192_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf193_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf194_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf195_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf195_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf196_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf197_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf197_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf198_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf199_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf19_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf1_DarkSkin_darkskin_BottomScrollButtonTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf200_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf201_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf202_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf201_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf202_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf203_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf204_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf205_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf206_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf207_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf208_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf209_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf207_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf208_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf209_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf20_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf210_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf211_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf212_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf213_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf214_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf215_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf216_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf217_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf218_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf219_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf210_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf211_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf212_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf213_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf214_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf21_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf220_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf221_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf222_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf223_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf224_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf225_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf226_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf227_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf22_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf23_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf24_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__; @@ -222,69 +209,76 @@ namespace vl_workflow_global struct __vwsnf62_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf63_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf64_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf65_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf66_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf67_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf68_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf69_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf65_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf66_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf67_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf68_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf69_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf6_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf70_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf71_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf70_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf71_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf72_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf73_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf74_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf75_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf76_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf77_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf78_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf79_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf73_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf74_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf75_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf76_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf77_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf78_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf79_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf7_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf80_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf81_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf80_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf81_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf82_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf83_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf84_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf85_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf86_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf87_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf88_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf89_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf87_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf88_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf89_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf8_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf90_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf91_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf92_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf93_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf94_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf95_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf96_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf97_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf98_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf99_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf90_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf91_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf92_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf93_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf94_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf95_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf96_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf97_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf98_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + struct __vwsnf99_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf9_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__; - class __vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc10_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc11_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc12_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc13_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc14_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; @@ -298,89 +292,89 @@ namespace vl_workflow_global class __vwsnc21_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc22_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc23_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc2_DarkSkin_darkskin_BottomScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc3_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc4_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc5_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc67_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc6_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc7_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc8_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc9_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; } @@ -484,11 +478,7 @@ namespace darkskin class VTrackerTemplate; class WindowTemplateConstructor; class WindowTemplate; -} -class ScrollTemplateScript; -namespace darkskin -{ class BottomScrollButtonTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { friend class ::vl_workflow_global::__vwsnc1_DarkSkin_darkskin_BottomScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; @@ -851,14 +841,25 @@ namespace darkskin class DatePickerTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { + friend class ::vl_workflow_global::__vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf62_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf63_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf64_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf65_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf66_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf67_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf68_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf69_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: ::darkskin::DatePickerTemplate* self = static_cast<::darkskin::DatePickerTemplate*>(nullptr); + ::vl::presentation::templates::GuiCommonDatePickerLook* look = static_cast<::vl::presentation::templates::GuiCommonDatePickerLook*>(nullptr); void __vwsn_initialize_instance_(::darkskin::DatePickerTemplate* __vwsn_this_); public: DatePickerTemplateConstructor(); @@ -867,9 +868,19 @@ namespace darkskin class DatePickerTemplate : public ::vl::presentation::templates::GuiDatePickerTemplate, public ::darkskin::DatePickerTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::DatePickerTemplateConstructor; + friend class ::vl_workflow_global::__vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf62_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf63_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf64_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf65_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf66_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf67_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf68_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf69_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -929,16 +940,17 @@ namespace darkskin class DocumentViewerTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend struct ::vl_workflow_global::__vwsnf65_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf66_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf70_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf71_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: - ::vl::presentation::compositions::GuiBoundsComposition* container = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::darkskin::DocumentViewerTemplate* self = static_cast<::darkskin::DocumentViewerTemplate*>(nullptr); + ::vl::presentation::templates::GuiCommonScrollViewLook* look = static_cast<::vl::presentation::templates::GuiCommonScrollViewLook*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement> __vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(); - ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_1 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); void __vwsn_initialize_instance_(::darkskin::DocumentViewerTemplate* __vwsn_this_); public: DocumentViewerTemplateConstructor(); @@ -947,8 +959,8 @@ namespace darkskin class DocumentViewerTemplate : public ::vl::presentation::templates::GuiDocumentViewerTemplate, public ::darkskin::DocumentViewerTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::DocumentViewerTemplateConstructor; - friend struct ::vl_workflow_global::__vwsnf65_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf66_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf70_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf71_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -959,18 +971,18 @@ namespace darkskin class ExpandingDecoratorTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf67_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf68_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf69_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf70_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf71_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf72_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf73_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf74_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf75_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf76_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf77_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -990,18 +1002,18 @@ namespace darkskin class ExpandingDecoratorTemplate : public ::vl::presentation::templates::GuiSelectableButtonTemplate, public ::darkskin::ExpandingDecoratorTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::ExpandingDecoratorTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf67_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf68_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf69_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf70_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf71_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf72_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf73_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf74_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf75_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf76_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf77_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1012,12 +1024,12 @@ namespace darkskin class GroupBoxTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf73_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf74_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf75_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf78_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf79_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf80_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1039,12 +1051,12 @@ namespace darkskin class GroupBoxTemplate : public ::vl::presentation::templates::GuiControlTemplate, public ::darkskin::GroupBoxTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::GroupBoxTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf73_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf74_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf75_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf78_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf79_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf80_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1055,8 +1067,8 @@ namespace darkskin class HScrollHandleTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf76_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf81_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1072,8 +1084,8 @@ namespace darkskin class HScrollHandleTemplate : public ::vl::presentation::templates::GuiButtonTemplate, public ::darkskin::HScrollHandleTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::HScrollHandleTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf76_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf81_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1084,43 +1096,30 @@ namespace darkskin class HScrollTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf77_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf78_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf79_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf80_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf81_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf82_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf83_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf84_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf85_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf86_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf87_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf88_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf89_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf90_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: ::darkskin::HScrollTemplate* self = static_cast<::darkskin::HScrollTemplate*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* invalidContainer = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::presentation::templates::GuiCommonScrollBehavior* behavior = static_cast<::vl::presentation::templates::GuiCommonScrollBehavior*>(nullptr); + ::vl::presentation::controls::GuiButton* buttonDecrease = static_cast<::vl::presentation::controls::GuiButton*>(nullptr); + ::vl::presentation::controls::GuiButton* buttonIncrease = static_cast<::vl::presentation::controls::GuiButton*>(nullptr); ::vl::presentation::compositions::GuiBoundsComposition* handleContainer = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::vl::presentation::compositions::GuiPartialViewComposition* handle = static_cast<::vl::presentation::compositions::GuiPartialViewComposition*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement> __vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(); ::vl::presentation::compositions::GuiSideAlignedComposition* __vwsn_precompile_1 = static_cast<::vl::presentation::compositions::GuiSideAlignedComposition*>(nullptr); - ::vl::presentation::controls::GuiButton* __vwsn_precompile_2 = static_cast<::vl::presentation::controls::GuiButton*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_3 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - ::vl::presentation::compositions::GuiSideAlignedComposition* __vwsn_precompile_4 = static_cast<::vl::presentation::compositions::GuiSideAlignedComposition*>(nullptr); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_2 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::presentation::compositions::GuiSideAlignedComposition* __vwsn_precompile_3 = static_cast<::vl::presentation::compositions::GuiSideAlignedComposition*>(nullptr); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_4 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::vl::presentation::controls::GuiButton* __vwsn_precompile_5 = static_cast<::vl::presentation::controls::GuiButton*>(nullptr); ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_6 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_7 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_8 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - ::vl::presentation::controls::GuiButton* __vwsn_precompile_9 = static_cast<::vl::presentation::controls::GuiButton*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_10 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); void __vwsn_initialize_instance_(::darkskin::HScrollTemplate* __vwsn_this_); public: HScrollTemplateConstructor(); @@ -1129,49 +1128,33 @@ namespace darkskin class HScrollTemplate : public ::vl::presentation::templates::GuiScrollTemplate, public ::darkskin::HScrollTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::HScrollTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf77_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf78_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf79_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf80_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf81_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf82_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf83_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf84_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf85_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf86_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf87_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf88_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf89_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf90_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif - protected: - bool draggingHandle = false; - ::vl::presentation::Point draggingStartLocation = [&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(0); __vwsn_temp__.y = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); public: HScrollTemplate(); + void __vwsn_instance_ctor_(); ~HScrollTemplate(); }; class HTrackerTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf91_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf92_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf93_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf94_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf95_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf87_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf88_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: ::darkskin::HTrackerTemplate* self = static_cast<::darkskin::HTrackerTemplate*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* invalidContainer = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::presentation::templates::GuiCommonScrollBehavior* behavior = static_cast<::vl::presentation::templates::GuiCommonScrollBehavior*>(nullptr); ::vl::presentation::compositions::GuiBoundsComposition* handle = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement> __vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(); ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); @@ -1189,27 +1172,22 @@ namespace darkskin class HTrackerTemplate : public ::vl::presentation::templates::GuiScrollTemplate, public ::darkskin::HTrackerTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::HTrackerTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf91_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf92_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf93_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf94_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf95_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf87_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf88_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif - protected: - bool draggingHandle = false; - ::vl::presentation::Point draggingStartLocation = [&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(0); __vwsn_temp__.y = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); public: HTrackerTemplate(); + void __vwsn_instance_ctor_(); ~HTrackerTemplate(); }; class ItemBackgroundTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf96_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf89_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1225,8 +1203,8 @@ namespace darkskin class ItemBackgroundTemplate : public ::vl::presentation::templates::GuiSelectableButtonTemplate, public ::darkskin::ItemBackgroundTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::ItemBackgroundTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf96_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf89_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1237,12 +1215,12 @@ namespace darkskin class LabelTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf97_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf98_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf99_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf90_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf91_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf92_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1257,12 +1235,12 @@ namespace darkskin class LabelTemplate : public ::vl::presentation::templates::GuiLabelTemplate, public ::darkskin::LabelTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::LabelTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf97_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf98_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf99_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf90_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf91_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf92_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1273,10 +1251,10 @@ namespace darkskin class LeftScrollButtonTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf100_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf101_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf93_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf94_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1293,10 +1271,10 @@ namespace darkskin class LeftScrollButtonTemplate : public ::vl::presentation::templates::GuiButtonTemplate, public ::darkskin::LeftScrollButtonTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::LeftScrollButtonTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf100_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf101_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf93_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf94_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1307,12 +1285,20 @@ namespace darkskin class ListViewColumnHeaderTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf100_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf101_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf102_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf103_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf104_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; @@ -1320,11 +1306,16 @@ namespace darkskin friend struct ::vl_workflow_global::__vwsnf106_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf107_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf108_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf109_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf95_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf96_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf97_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf98_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf99_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: + ::vl::presentation::compositions::GuiBoundsComposition* container = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::darkskin::ListViewColumnHeaderTemplate* self = static_cast<::darkskin::ListViewColumnHeaderTemplate*>(nullptr); ::vl::presentation::controls::GuiSelectableButton* buttonArrow = static_cast<::vl::presentation::controls::GuiSelectableButton*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement> __vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(); @@ -1332,11 +1323,16 @@ namespace darkskin ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_3 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_4 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_5 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_6 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - ::vl::Ptr<::vl::presentation::elements::GuiSolidLabelElement> __vwsn_precompile_7 = ::vl::Ptr<::vl::presentation::elements::GuiSolidLabelElement>(); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_8 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::presentation::compositions::GuiTableComposition* __vwsn_precompile_5 = static_cast<::vl::presentation::compositions::GuiTableComposition*>(nullptr); + ::vl::presentation::compositions::GuiCellComposition* __vwsn_precompile_6 = static_cast<::vl::presentation::compositions::GuiCellComposition*>(nullptr); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_7 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::Ptr<::vl::presentation::elements::GuiPolygonElement> __vwsn_precompile_8 = ::vl::Ptr<::vl::presentation::elements::GuiPolygonElement>(); ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_9 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::Ptr<::vl::presentation::elements::GuiPolygonElement> __vwsn_precompile_10 = ::vl::Ptr<::vl::presentation::elements::GuiPolygonElement>(); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_11 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::Ptr<::vl::presentation::elements::GuiSolidLabelElement> __vwsn_precompile_12 = ::vl::Ptr<::vl::presentation::elements::GuiSolidLabelElement>(); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_13 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_14 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); void __vwsn_initialize_instance_(::darkskin::ListViewColumnHeaderTemplate* __vwsn_this_); public: ListViewColumnHeaderTemplateConstructor(); @@ -1345,12 +1341,20 @@ namespace darkskin class ListViewColumnHeaderTemplate : public ::vl::presentation::templates::GuiListViewColumnHeaderTemplate, public ::darkskin::ListViewColumnHeaderTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::ListViewColumnHeaderTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf100_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf101_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf102_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf103_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf104_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; @@ -1358,7 +1362,11 @@ namespace darkskin friend struct ::vl_workflow_global::__vwsnf106_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf107_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf108_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf109_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf95_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf96_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf97_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf98_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf99_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1369,18 +1377,19 @@ namespace darkskin class ListViewTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { + friend struct ::vl_workflow_global::__vwsnf109_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf110_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf111_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf112_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf113_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: - ::vl::presentation::compositions::GuiBoundsComposition* container = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::darkskin::ListViewTemplate* self = static_cast<::darkskin::ListViewTemplate*>(nullptr); + ::vl::presentation::templates::GuiCommonScrollViewLook* look = static_cast<::vl::presentation::templates::GuiCommonScrollViewLook*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement> __vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(); - ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_1 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); void __vwsn_initialize_instance_(::darkskin::ListViewTemplate* __vwsn_this_); public: ListViewTemplateConstructor(); @@ -1389,10 +1398,10 @@ namespace darkskin class ListViewTemplate : public ::vl::presentation::templates::GuiListViewTemplate, public ::darkskin::ListViewTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::ListViewTemplateConstructor; + friend struct ::vl_workflow_global::__vwsnf109_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf110_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf111_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf112_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf113_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1403,15 +1412,15 @@ namespace darkskin class MenuBarButtonTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf113_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf114_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf115_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf116_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf117_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf118_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1428,15 +1437,15 @@ namespace darkskin class MenuBarButtonTemplate : public ::vl::presentation::templates::GuiToolstripButtonTemplate, public ::darkskin::MenuBarButtonTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::MenuBarButtonTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf113_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf114_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf115_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf116_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf117_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf118_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1447,19 +1456,20 @@ namespace darkskin class MenuItemButtonTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc67_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf118_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf119_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf120_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf121_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; @@ -1473,7 +1483,6 @@ namespace darkskin friend struct ::vl_workflow_global::__vwsnf129_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf130_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf131_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf132_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1499,19 +1508,20 @@ namespace darkskin class MenuItemButtonTemplate : public ::vl::presentation::templates::GuiToolstripButtonTemplate, public ::darkskin::MenuItemButtonTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::MenuItemButtonTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc67_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf118_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf119_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf120_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf121_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; @@ -1525,7 +1535,6 @@ namespace darkskin friend struct ::vl_workflow_global::__vwsnf129_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf130_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf131_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf132_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1562,16 +1571,17 @@ namespace darkskin class MultilineTextBoxTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { + friend struct ::vl_workflow_global::__vwsnf132_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf133_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf134_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: - ::vl::presentation::compositions::GuiBoundsComposition* container = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::darkskin::MultilineTextBoxTemplate* self = static_cast<::darkskin::MultilineTextBoxTemplate*>(nullptr); + ::vl::presentation::templates::GuiCommonScrollViewLook* look = static_cast<::vl::presentation::templates::GuiCommonScrollViewLook*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement> __vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(); - ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_1 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); void __vwsn_initialize_instance_(::darkskin::MultilineTextBoxTemplate* __vwsn_this_); public: MultilineTextBoxTemplateConstructor(); @@ -1580,8 +1590,8 @@ namespace darkskin class MultilineTextBoxTemplate : public ::vl::presentation::templates::GuiMultilineTextBoxTemplate, public ::darkskin::MultilineTextBoxTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::MultilineTextBoxTemplateConstructor; + friend struct ::vl_workflow_global::__vwsnf132_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf133_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf134_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1592,8 +1602,8 @@ namespace darkskin class ProgressBarTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf135_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf134_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1613,8 +1623,8 @@ namespace darkskin class ProgressBarTemplate : public ::vl::presentation::templates::GuiScrollTemplate, public ::darkskin::ProgressBarTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::ProgressBarTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf135_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf134_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1625,20 +1635,20 @@ namespace darkskin class RadioButtonTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf135_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf136_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf137_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf138_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf139_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf140_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf141_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf142_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1663,20 +1673,20 @@ namespace darkskin class RadioButtonTemplate : public ::vl::presentation::templates::GuiSelectableButtonTemplate, public ::darkskin::RadioButtonTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::RadioButtonTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf135_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf136_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf137_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf138_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf139_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf140_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf141_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf142_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1687,10 +1697,10 @@ namespace darkskin class RightScrollButtonTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf142_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf143_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf144_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1707,10 +1717,10 @@ namespace darkskin class RightScrollButtonTemplate : public ::vl::presentation::templates::GuiButtonTemplate, public ::darkskin::RightScrollButtonTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::RightScrollButtonTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf142_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf143_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf144_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1721,13 +1731,14 @@ namespace darkskin class ScrollViewTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { + friend struct ::vl_workflow_global::__vwsnf144_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf145_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf146_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: ::darkskin::ScrollViewTemplate* self = static_cast<::darkskin::ScrollViewTemplate*>(nullptr); + ::vl::presentation::templates::GuiCommonScrollViewLook* look = static_cast<::vl::presentation::templates::GuiCommonScrollViewLook*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement> __vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(); ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); @@ -1739,8 +1750,8 @@ namespace darkskin class ScrollViewTemplate : public ::vl::presentation::templates::GuiScrollViewTemplate, public ::darkskin::ScrollViewTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::ScrollViewTemplateConstructor; + friend struct ::vl_workflow_global::__vwsnf144_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf145_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf146_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1751,12 +1762,12 @@ namespace darkskin class ShortcutKeyTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf146_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf147_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf148_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf149_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1775,12 +1786,12 @@ namespace darkskin class ShortcutKeyTemplate : public ::vl::presentation::templates::GuiLabelTemplate, public ::darkskin::ShortcutKeyTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::ShortcutKeyTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf146_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf147_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf148_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf149_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1817,14 +1828,14 @@ namespace darkskin class TabHeaderButtonTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf149_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf150_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf151_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf152_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf153_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1841,14 +1852,14 @@ namespace darkskin class TabHeaderButtonTemplate : public ::vl::presentation::templates::GuiSelectableButtonTemplate, public ::darkskin::TabHeaderButtonTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::TabHeaderButtonTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf149_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf150_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf151_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf152_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf153_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1859,14 +1870,14 @@ namespace darkskin class TabHeaderTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf153_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf155_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf156_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf158_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1883,14 +1894,14 @@ namespace darkskin class TabHeaderTemplate : public ::vl::presentation::templates::GuiControlTemplate, public ::darkskin::TabHeaderTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::TabHeaderTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf153_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf155_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf156_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf158_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1907,12 +1918,12 @@ namespace darkskin class TabTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf158_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf159_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf160_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf161_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf162_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf163_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1935,12 +1946,12 @@ namespace darkskin class TabTemplate : public ::vl::presentation::templates::GuiTabTemplate, public ::darkskin::TabTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::TabTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf158_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf159_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf160_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf161_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf162_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf163_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1952,19 +1963,20 @@ namespace darkskin class TextListTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { + friend struct ::vl_workflow_global::__vwsnf163_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf164_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf165_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf166_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf167_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf168_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: - ::vl::presentation::compositions::GuiBoundsComposition* container = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::darkskin::TextListTemplate* self = static_cast<::darkskin::TextListTemplate*>(nullptr); + ::vl::presentation::templates::GuiCommonScrollViewLook* look = static_cast<::vl::presentation::templates::GuiCommonScrollViewLook*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement> __vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(); - ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_1 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); void __vwsn_initialize_instance_(::darkskin::TextListTemplate* __vwsn_this_); public: TextListTemplateConstructor(); @@ -1973,11 +1985,11 @@ namespace darkskin class TextListTemplate : public ::vl::presentation::templates::GuiTextListTemplate, public ::darkskin::TextListTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::TextListTemplateConstructor; + friend struct ::vl_workflow_global::__vwsnf163_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf164_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf165_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf166_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf167_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf168_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1988,12 +2000,12 @@ namespace darkskin class ToolstripSplitArrowTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf168_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf169_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf170_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf171_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2011,12 +2023,12 @@ namespace darkskin class ToolstripSplitArrowTemplate : public ::vl::presentation::templates::GuiSelectableButtonTemplate, public ::darkskin::ToolstripSplitArrowTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::ToolstripSplitArrowTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf168_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf169_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf170_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf171_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2027,17 +2039,17 @@ namespace darkskin class ToolstripButtonTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf171_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf172_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf173_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf174_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf175_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf176_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf177_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2057,17 +2069,17 @@ namespace darkskin class ToolstripButtonTemplate : public ::vl::presentation::templates::GuiToolstripButtonTemplate, public ::darkskin::ToolstripButtonTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::ToolstripButtonTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf171_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf172_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf173_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf174_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf175_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf176_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf177_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2078,14 +2090,15 @@ namespace darkskin class ToolstripDropdownButtonTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf177_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf178_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf179_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf180_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; @@ -2094,7 +2107,6 @@ namespace darkskin friend struct ::vl_workflow_global::__vwsnf183_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf184_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf185_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf186_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2118,14 +2130,15 @@ namespace darkskin class ToolstripDropdownButtonTemplate : public ::vl::presentation::templates::GuiToolstripButtonTemplate, public ::darkskin::ToolstripDropdownButtonTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::ToolstripDropdownButtonTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf177_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf178_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf179_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf180_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; @@ -2134,7 +2147,6 @@ namespace darkskin friend struct ::vl_workflow_global::__vwsnf183_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf184_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf185_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf186_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2171,13 +2183,14 @@ namespace darkskin class ToolstripSplitButtonTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf186_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf187_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf188_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf189_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; @@ -2186,7 +2199,6 @@ namespace darkskin friend struct ::vl_workflow_global::__vwsnf192_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf193_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf194_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf195_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2211,13 +2223,14 @@ namespace darkskin class ToolstripSplitButtonTemplate : public ::vl::presentation::templates::GuiToolstripButtonTemplate, public ::darkskin::ToolstripSplitButtonTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::ToolstripSplitButtonTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf186_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf187_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf188_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf189_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; @@ -2226,7 +2239,6 @@ namespace darkskin friend struct ::vl_workflow_global::__vwsnf192_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf193_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf194_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf195_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2314,10 +2326,10 @@ namespace darkskin class TopScrollButtonTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf195_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf196_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf197_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2334,10 +2346,10 @@ namespace darkskin class TopScrollButtonTemplate : public ::vl::presentation::templates::GuiButtonTemplate, public ::darkskin::TopScrollButtonTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::TopScrollButtonTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf195_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf196_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf197_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2348,18 +2360,19 @@ namespace darkskin class TreeViewTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { + friend struct ::vl_workflow_global::__vwsnf197_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf198_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf199_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf200_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf201_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: - ::vl::presentation::compositions::GuiBoundsComposition* container = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::darkskin::TreeViewTemplate* self = static_cast<::darkskin::TreeViewTemplate*>(nullptr); + ::vl::presentation::templates::GuiCommonScrollViewLook* look = static_cast<::vl::presentation::templates::GuiCommonScrollViewLook*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement> __vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(); - ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_1 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement> __vwsn_precompile_2 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBorderElement>(); void __vwsn_initialize_instance_(::darkskin::TreeViewTemplate* __vwsn_this_); public: TreeViewTemplateConstructor(); @@ -2368,10 +2381,10 @@ namespace darkskin class TreeViewTemplate : public ::vl::presentation::templates::GuiTreeViewTemplate, public ::darkskin::TreeViewTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::TreeViewTemplateConstructor; + friend struct ::vl_workflow_global::__vwsnf197_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf198_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf199_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf200_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf201_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2382,8 +2395,8 @@ namespace darkskin class VScrollHandleTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf202_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf201_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2399,8 +2412,8 @@ namespace darkskin class VScrollHandleTemplate : public ::vl::presentation::templates::GuiButtonTemplate, public ::darkskin::VScrollHandleTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::VScrollHandleTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf202_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf201_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2411,43 +2424,30 @@ namespace darkskin class VScrollTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf202_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf203_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf204_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf205_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf206_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf207_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf208_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf209_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf210_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf211_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf212_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf213_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf214_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf215_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf216_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: ::darkskin::VScrollTemplate* self = static_cast<::darkskin::VScrollTemplate*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* invalidContainer = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::presentation::templates::GuiCommonScrollBehavior* behavior = static_cast<::vl::presentation::templates::GuiCommonScrollBehavior*>(nullptr); + ::vl::presentation::controls::GuiButton* buttonDecrease = static_cast<::vl::presentation::controls::GuiButton*>(nullptr); + ::vl::presentation::controls::GuiButton* buttonIncrease = static_cast<::vl::presentation::controls::GuiButton*>(nullptr); ::vl::presentation::compositions::GuiBoundsComposition* handleContainer = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::vl::presentation::compositions::GuiPartialViewComposition* handle = static_cast<::vl::presentation::compositions::GuiPartialViewComposition*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement> __vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(); ::vl::presentation::compositions::GuiSideAlignedComposition* __vwsn_precompile_1 = static_cast<::vl::presentation::compositions::GuiSideAlignedComposition*>(nullptr); - ::vl::presentation::controls::GuiButton* __vwsn_precompile_2 = static_cast<::vl::presentation::controls::GuiButton*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_3 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - ::vl::presentation::compositions::GuiSideAlignedComposition* __vwsn_precompile_4 = static_cast<::vl::presentation::compositions::GuiSideAlignedComposition*>(nullptr); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_2 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::presentation::compositions::GuiSideAlignedComposition* __vwsn_precompile_3 = static_cast<::vl::presentation::compositions::GuiSideAlignedComposition*>(nullptr); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_4 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::vl::presentation::controls::GuiButton* __vwsn_precompile_5 = static_cast<::vl::presentation::controls::GuiButton*>(nullptr); ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_6 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_7 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_8 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); - ::vl::presentation::controls::GuiButton* __vwsn_precompile_9 = static_cast<::vl::presentation::controls::GuiButton*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_10 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); void __vwsn_initialize_instance_(::darkskin::VScrollTemplate* __vwsn_this_); public: VScrollTemplateConstructor(); @@ -2456,49 +2456,33 @@ namespace darkskin class VScrollTemplate : public ::vl::presentation::templates::GuiScrollTemplate, public ::darkskin::VScrollTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::VScrollTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf202_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf203_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf204_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf205_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf206_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf207_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf208_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf209_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf210_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf211_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf212_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf213_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf214_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf215_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf216_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif - protected: - bool draggingHandle = false; - ::vl::presentation::Point draggingStartLocation = [&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(0); __vwsn_temp__.y = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); public: VScrollTemplate(); + void __vwsn_instance_ctor_(); ~VScrollTemplate(); }; class VTrackerTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf217_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf218_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf219_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf220_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf221_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf207_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf208_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif protected: ::darkskin::VTrackerTemplate* self = static_cast<::darkskin::VTrackerTemplate*>(nullptr); - ::vl::presentation::compositions::GuiBoundsComposition* invalidContainer = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::presentation::templates::GuiCommonScrollBehavior* behavior = static_cast<::vl::presentation::templates::GuiCommonScrollBehavior*>(nullptr); ::vl::presentation::compositions::GuiBoundsComposition* handle = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement> __vwsn_precompile_0 = ::vl::Ptr<::vl::presentation::elements::GuiSolidBackgroundElement>(); ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_1 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); @@ -2516,33 +2500,28 @@ namespace darkskin class VTrackerTemplate : public ::vl::presentation::templates::GuiScrollTemplate, public ::darkskin::VTrackerTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::VTrackerTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf217_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf218_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf219_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf220_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf221_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf207_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf208_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif - protected: - bool draggingHandle = false; - ::vl::presentation::Point draggingStartLocation = [&](){ ::vl::presentation::Point __vwsn_temp__; __vwsn_temp__.x = static_cast<::vl::vint>(0); __vwsn_temp__.y = static_cast<::vl::vint>(0); return __vwsn_temp__; }(); public: VTrackerTemplate(); + void __vwsn_instance_ctor_(); ~VTrackerTemplate(); }; class WindowTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf222_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf223_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf224_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf225_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf226_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf227_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf209_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf210_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf211_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf212_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf213_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf214_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2582,14 +2561,14 @@ namespace darkskin class WindowTemplate : public ::vl::presentation::templates::GuiWindowTemplate, public ::darkskin::WindowTemplateConstructor, public ::vl::reflection::Description { friend class ::darkskin::WindowTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend class ::vl_workflow_global::__vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf222_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf223_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf224_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf225_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf226_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; - friend struct ::vl_workflow_global::__vwsnf227_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend class ::vl_workflow_global::__vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf209_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf210_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf211_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf212_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf213_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf214_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -2599,16 +2578,6 @@ namespace darkskin }; } -class ScrollTemplateScript : public ::vl::Object, public ::vl::reflection::Description -{ -#ifndef VCZH_DEBUG_NO_REFLECTION - friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; -#endif -public: - static void SetScroll(::vl::vint totalPixels, ::vl::vint newOffset, ::vl::presentation::templates::GuiScrollTemplate* scrollTemplate); - ScrollTemplateScript(); -}; - /*********************************************************************** Global Variables and Functions ***********************************************************************/ @@ -2626,20 +2595,20 @@ namespace vl_workflow_global Closures ***********************************************************************/ - struct __vwsnf100_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf100_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::LeftScrollButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - __vwsnf100_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnf100_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf101_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf101_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::LeftScrollButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - __vwsnf101_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnf101_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; @@ -2650,7 +2619,7 @@ Closures __vwsnf102_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf103_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__ @@ -2659,7 +2628,7 @@ Closures __vwsnf103_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf104_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__ @@ -2707,13 +2676,13 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf109_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf109_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewTemplateConstructor* __vwsnthis_0; - __vwsnf109_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); + __vwsnf109_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiListViewColumnHeaderTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf10_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__ @@ -2731,7 +2700,7 @@ Closures __vwsnf110_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiListViewColumnHeaderTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + ::vl::presentation::templates::GuiSelectableButtonTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf111_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__ @@ -2740,7 +2709,7 @@ Closures __vwsnf111_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiSelectableButtonTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf112_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__ @@ -2752,13 +2721,13 @@ Closures ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; - struct __vwsnf113_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf113_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ListViewTemplateConstructor* __vwsnthis_0; + ::darkskin::MenuBarButtonTemplateConstructor* __vwsnthis_0; - __vwsnf113_DarkSkin_darkskin_ListViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewTemplateConstructor* __vwsnctorthis_0); + __vwsnf113_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf114_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__ @@ -2767,7 +2736,7 @@ Closures __vwsnf114_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf115_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__ @@ -2797,13 +2766,13 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf118_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf118_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::MenuBarButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; - __vwsnf118_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnf118_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf119_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__ @@ -2812,7 +2781,7 @@ Closures __vwsnf119_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf11_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__ @@ -2941,13 +2910,13 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf132_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf132_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::MultilineTextBoxTemplateConstructor* __vwsnthis_0; - __vwsnf132_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnf132_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::MultilineTextBoxTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf133_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__ @@ -2959,20 +2928,20 @@ Closures ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; - struct __vwsnf134_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::MultilineTextBoxTemplateConstructor* __vwsnthis_0; - - __vwsnf134_DarkSkin_darkskin_MultilineTextBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::MultilineTextBoxTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; - }; - - struct __vwsnf135_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf134_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__ { ::darkskin::ProgressBarTemplateConstructor* __vwsnthis_0; - __vwsnf135_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__(::darkskin::ProgressBarTemplateConstructor* __vwsnctorthis_0); + __vwsnf134_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance__(::darkskin::ProgressBarTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf135_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; + + __vwsnf135_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; @@ -3040,11 +3009,11 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf142_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf142_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::RightScrollButtonTemplateConstructor* __vwsnthis_0; - __vwsnf142_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnf142_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; @@ -3058,13 +3027,13 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf144_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf144_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::RightScrollButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ScrollViewTemplateConstructor* __vwsnthis_0; - __vwsnf144_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnf144_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::ScrollViewTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf145_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__ @@ -3076,13 +3045,13 @@ Closures ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; - struct __vwsnf146_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf146_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ScrollViewTemplateConstructor* __vwsnthis_0; + ::darkskin::ShortcutKeyTemplateConstructor* __vwsnthis_0; - __vwsnf146_DarkSkin_darkskin_ScrollViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::ScrollViewTemplateConstructor* __vwsnctorthis_0); + __vwsnf146_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf147_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__ @@ -3103,11 +3072,11 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf149_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf149_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ShortcutKeyTemplateConstructor* __vwsnthis_0; + ::darkskin::TabHeaderButtonTemplateConstructor* __vwsnthis_0; - __vwsnf149_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance__(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0); + __vwsnf149_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; @@ -3148,13 +3117,13 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf153_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf153_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::TabHeaderButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::TabHeaderTemplateConstructor* __vwsnthis_0; - __vwsnf153_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnf153_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__ @@ -3163,7 +3132,7 @@ Closures __vwsnf154_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf155_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__ @@ -3190,16 +3159,16 @@ Closures __vwsnf157_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; }; - struct __vwsnf158_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf158_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::TabHeaderTemplateConstructor* __vwsnthis_0; + ::darkskin::TabTemplateConstructor* __vwsnthis_0; - __vwsnf158_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0); + __vwsnf158_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + ::vl::presentation::templates::GuiTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf159_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__ @@ -3208,7 +3177,7 @@ Closures __vwsnf159_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf15_DarkSkin_darkskin_CheckItemBackgroundTemplateConstructor___vwsn_initialize_instance__ @@ -3226,7 +3195,7 @@ Closures __vwsnf160_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiItemEventArgs* arguments) const; }; struct __vwsnf161_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__ @@ -3244,16 +3213,16 @@ Closures __vwsnf162_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiItemEventArgs* arguments) const; + void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; }; - struct __vwsnf163_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf163_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::TabTemplateConstructor* __vwsnthis_0; + ::darkskin::TextListTemplateConstructor* __vwsnthis_0; - __vwsnf163_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance__(::darkskin::TabTemplateConstructor* __vwsnctorthis_0); + __vwsnf163_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(::darkskin::TextListTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + ::vl::presentation::templates::GuiSelectableButtonTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf164_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__ @@ -3280,7 +3249,7 @@ Closures __vwsnf166_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(::darkskin::TextListTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiSelectableButtonTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf167_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__ @@ -3292,13 +3261,13 @@ Closures ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; - struct __vwsnf168_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf168_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::TextListTemplateConstructor* __vwsnthis_0; + ::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnthis_0; - __vwsnf168_DarkSkin_darkskin_TextListTemplateConstructor___vwsn_initialize_instance__(::darkskin::TextListTemplateConstructor* __vwsnctorthis_0); + __vwsnf168_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf169_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__ @@ -3328,13 +3297,13 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf171_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf171_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnthis_0; + ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; - __vwsnf171_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0); + __vwsnf171_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf172_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__ @@ -3343,7 +3312,7 @@ Closures __vwsnf172_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf173_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__ @@ -3382,13 +3351,13 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf177_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf177_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; - __vwsnf177_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnf177_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf178_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__ @@ -3397,7 +3366,7 @@ Closures __vwsnf178_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf179_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__ @@ -3472,13 +3441,13 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf186_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf186_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; - __vwsnf186_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnf186_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf187_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__ @@ -3487,7 +3456,7 @@ Closures __vwsnf187_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf188_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__ @@ -3496,7 +3465,7 @@ Closures __vwsnf188_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf189_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__ @@ -3562,11 +3531,11 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf195_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf195_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::TopScrollButtonTemplateConstructor* __vwsnthis_0; - __vwsnf195_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnf195_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; @@ -3580,13 +3549,13 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf197_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf197_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::TopScrollButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::TreeViewTemplateConstructor* __vwsnthis_0; - __vwsnf197_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnf197_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::TreeViewTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiSelectableButtonTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf198_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__ @@ -3604,7 +3573,7 @@ Closures __vwsnf199_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::TreeViewTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiSelectableButtonTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf19_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__ @@ -3634,24 +3603,24 @@ Closures ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; - struct __vwsnf201_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::TreeViewTemplateConstructor* __vwsnthis_0; - - __vwsnf201_DarkSkin_darkskin_TreeViewTemplateConstructor___vwsn_initialize_instance__(::darkskin::TreeViewTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; - }; - - struct __vwsnf202_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf201_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__ { ::darkskin::VScrollHandleTemplateConstructor* __vwsnthis_0; - __vwsnf202_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollHandleTemplateConstructor* __vwsnctorthis_0); + __vwsnf201_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollHandleTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; + struct __vwsnf202_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; + + __vwsnf202_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); + + ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + }; + struct __vwsnf203_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ { ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; @@ -3676,7 +3645,7 @@ Closures __vwsnf205_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf206_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ @@ -3685,34 +3654,34 @@ Closures __vwsnf206_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf207_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf207_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; + ::darkskin::VTrackerTemplateConstructor* __vwsnthis_0; - __vwsnf207_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); + __vwsnf207_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; - struct __vwsnf208_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf208_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; + ::darkskin::VTrackerTemplateConstructor* __vwsnthis_0; - __vwsnf208_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); + __vwsnf208_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf209_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf209_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; + ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - __vwsnf209_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); + __vwsnf209_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; + ::vl::presentation::templates::GuiWindowTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf20_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__ @@ -3724,94 +3693,49 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf210_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf210_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; + ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - __vwsnf210_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); - - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; - }; - - struct __vwsnf211_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; - - __vwsnf211_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); - - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; - }; - - struct __vwsnf212_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; - - __vwsnf212_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); - - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; - }; - - struct __vwsnf213_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; - - __vwsnf213_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); - - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; - }; - - struct __vwsnf214_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; - - __vwsnf214_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); - - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; - }; - - struct __vwsnf215_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; - - __vwsnf215_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); - - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; - }; - - struct __vwsnf216_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; - - __vwsnf216_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); - - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; - }; - - struct __vwsnf217_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::VTrackerTemplateConstructor* __vwsnthis_0; - - __vwsnf217_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0); + __vwsnf210_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; - struct __vwsnf218_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf211_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::VTrackerTemplateConstructor* __vwsnthis_0; + ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - __vwsnf218_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0); + __vwsnf211_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); + + ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + }; + + struct __vwsnf212_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::WindowTemplateConstructor* __vwsnthis_0; + + __vwsnf212_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); + + ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + }; + + struct __vwsnf213_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::WindowTemplateConstructor* __vwsnthis_0; + + __vwsnf213_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf219_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf214_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::VTrackerTemplateConstructor* __vwsnthis_0; + ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - __vwsnf219_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0); + __vwsnf214_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf21_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__ @@ -3823,78 +3747,6 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf220_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::VTrackerTemplateConstructor* __vwsnthis_0; - - __vwsnf220_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0); - - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; - }; - - struct __vwsnf221_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::VTrackerTemplateConstructor* __vwsnthis_0; - - __vwsnf221_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0); - - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; - }; - - struct __vwsnf222_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - - __vwsnf222_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::templates::GuiWindowTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; - }; - - struct __vwsnf223_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - - __vwsnf223_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; - }; - - struct __vwsnf224_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - - __vwsnf224_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; - }; - - struct __vwsnf225_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - - __vwsnf225_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; - }; - - struct __vwsnf226_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - - __vwsnf226_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); - - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; - }; - - struct __vwsnf227_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - - __vwsnf227_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance__(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); - - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; - }; - struct __vwsnf22_DarkSkin_darkskin_ComboBoxTemplateConstructor___vwsn_initialize_instance__ { ::darkskin::ComboBoxTemplateConstructor* __vwsnthis_0; @@ -4318,47 +4170,47 @@ Closures ::vl::presentation::templates::GuiSelectableButtonTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; - struct __vwsnf65_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf65_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::DocumentViewerTemplateConstructor* __vwsnthis_0; + ::darkskin::DatePickerTemplateConstructor* __vwsnthis_0; - __vwsnf65_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DocumentViewerTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; - }; - - struct __vwsnf66_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::DocumentViewerTemplateConstructor* __vwsnthis_0; - - __vwsnf66_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DocumentViewerTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; - }; - - struct __vwsnf67_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; - - __vwsnf67_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + __vwsnf65_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf68_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf66_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + ::darkskin::DatePickerTemplateConstructor* __vwsnthis_0; - __vwsnf68_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + __vwsnf66_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf69_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf67_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + ::darkskin::DatePickerTemplateConstructor* __vwsnthis_0; - __vwsnf69_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + __vwsnf67_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf68_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::DatePickerTemplateConstructor* __vwsnthis_0; + + __vwsnf68_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf69_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::DatePickerTemplateConstructor* __vwsnthis_0; + + __vwsnf69_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; @@ -4372,22 +4224,22 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf70_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf70_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + ::darkskin::DocumentViewerTemplateConstructor* __vwsnthis_0; - __vwsnf70_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + __vwsnf70_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DocumentViewerTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; - struct __vwsnf71_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf71_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + ::darkskin::DocumentViewerTemplateConstructor* __vwsnthis_0; - __vwsnf71_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + __vwsnf71_DarkSkin_darkskin_DocumentViewerTemplateConstructor___vwsn_initialize_instance__(::darkskin::DocumentViewerTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiScrollTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf72_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__ @@ -4399,69 +4251,69 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf73_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf73_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + + __vwsnf73_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf74_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + + __vwsnf74_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf75_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + + __vwsnf75_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf76_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + + __vwsnf76_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf77_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + + __vwsnf77_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance__(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf78_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__ { ::darkskin::GroupBoxTemplateConstructor* __vwsnthis_0; - __vwsnf73_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); + __vwsnf78_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf74_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf79_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__ { ::darkskin::GroupBoxTemplateConstructor* __vwsnthis_0; - __vwsnf74_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); + __vwsnf79_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf75_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::GroupBoxTemplateConstructor* __vwsnthis_0; - - __vwsnf75_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); - - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; - }; - - struct __vwsnf76_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::HScrollHandleTemplateConstructor* __vwsnthis_0; - - __vwsnf76_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollHandleTemplateConstructor* __vwsnctorthis_0); - - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; - }; - - struct __vwsnf77_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; - - __vwsnf77_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; - }; - - struct __vwsnf78_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; - - __vwsnf78_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; - }; - - struct __vwsnf79_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; - - __vwsnf79_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; - }; - struct __vwsnf7_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance__ { ::darkskin::ButtonTemplateConstructor* __vwsnthis_0; @@ -4471,22 +4323,22 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf80_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf80_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; + ::darkskin::GroupBoxTemplateConstructor* __vwsnthis_0; - __vwsnf80_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); + __vwsnf80_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance__(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf81_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf81_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; + ::darkskin::HScrollHandleTemplateConstructor* __vwsnthis_0; - __vwsnf81_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); + __vwsnf81_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollHandleTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf82_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ @@ -4495,7 +4347,7 @@ Closures __vwsnf82_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf83_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ @@ -4504,7 +4356,7 @@ Closures __vwsnf83_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; + ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf84_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ @@ -4513,7 +4365,7 @@ Closures __vwsnf84_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf85_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ @@ -4522,7 +4374,7 @@ Closures __vwsnf85_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf86_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ @@ -4534,31 +4386,31 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf87_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf87_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; + ::darkskin::HTrackerTemplateConstructor* __vwsnthis_0; - __vwsnf87_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); + __vwsnf87_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0); + + ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + }; + + struct __vwsnf88_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::HTrackerTemplateConstructor* __vwsnthis_0; + + __vwsnf88_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf88_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf89_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; + ::darkskin::ItemBackgroundTemplateConstructor* __vwsnthis_0; - __vwsnf88_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); + __vwsnf89_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__(::darkskin::ItemBackgroundTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; - }; - - struct __vwsnf89_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; - - __vwsnf89_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); - - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf8_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance__ @@ -4570,92 +4422,92 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf90_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf90_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; + ::darkskin::LabelTemplateConstructor* __vwsnthis_0; - __vwsnf90_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance__(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); + __vwsnf90_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf91_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf91_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::HTrackerTemplateConstructor* __vwsnthis_0; + ::darkskin::LabelTemplateConstructor* __vwsnthis_0; - __vwsnf91_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0); + __vwsnf91_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf92_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::LabelTemplateConstructor* __vwsnthis_0; + + __vwsnf92_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf93_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::LeftScrollButtonTemplateConstructor* __vwsnthis_0; + + __vwsnf93_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf94_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::LeftScrollButtonTemplateConstructor* __vwsnthis_0; + + __vwsnf94_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance__(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0); + + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + }; + + struct __vwsnf95_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; + + __vwsnf95_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); + + ::vl::presentation::templates::GuiMenuTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + }; + + struct __vwsnf96_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__ + { + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; + + __vwsnf96_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); ::vl::presentation::templates::GuiControlTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; - struct __vwsnf92_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf97_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::HTrackerTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - __vwsnf92_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0); + __vwsnf97_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf93_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf98_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::HTrackerTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - __vwsnf93_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0); - - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; - }; - - struct __vwsnf94_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::HTrackerTemplateConstructor* __vwsnthis_0; - - __vwsnf94_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0); - - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; - }; - - struct __vwsnf95_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::HTrackerTemplateConstructor* __vwsnthis_0; - - __vwsnf95_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance__(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0); - - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiMouseEventArgs* arguments) const; - }; - - struct __vwsnf96_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::ItemBackgroundTemplateConstructor* __vwsnthis_0; - - __vwsnf96_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance__(::darkskin::ItemBackgroundTemplateConstructor* __vwsnctorthis_0); + __vwsnf98_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf97_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf99_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__ { - ::darkskin::LabelTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - __vwsnf97_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); - - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; - }; - - struct __vwsnf98_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::LabelTemplateConstructor* __vwsnthis_0; - - __vwsnf98_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); - - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; - }; - - struct __vwsnf99_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__ - { - ::darkskin::LabelTemplateConstructor* __vwsnthis_0; - - __vwsnf99_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance__(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); + __vwsnf99_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance__(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; @@ -4669,14 +4521,83 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - class __vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnthis_0; - __vwsnc100_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc100_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0); - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripSplitArrowTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripSplitArrowTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ToolstripSplitArrowTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc101_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc102_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc103_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -4687,14 +4608,14 @@ Closures bool Close() override; }; - class __vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; - __vwsnc101_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc104_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -4705,12 +4626,51 @@ Closures bool Close() override; }; - class __vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc105_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; - __vwsnc102_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc106_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc107_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_1 = nullptr; @@ -4729,143 +4689,32 @@ Closures bool Close() override; }; - class __vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; - __vwsnc103_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc108_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_2 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); bool Open() override; bool Update() override; bool Close() override; }; - class __vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; - __vwsnc104_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc109_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_2 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc105_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc106_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_2 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc107_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc108_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc109_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -4897,12 +4746,102 @@ Closures bool Close() override; }; - class __vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc110_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc111_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc112_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc113_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; - __vwsnc110_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc114_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_1 = nullptr; @@ -4918,12 +4857,36 @@ Closures bool Close() override; }; - class __vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; - __vwsnc111_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc115_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc116_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -4936,101 +4899,14 @@ Closures bool Close() override; }; - class __vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::TopScrollButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; - __vwsnc112_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc117_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); - ::darkskin::TopScrollButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::TopScrollButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::TopScrollButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc113_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::TopScrollButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::TopScrollButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::VScrollHandleTemplateConstructor* __vwsnthis_0; - - __vwsnc114_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollHandleTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::VScrollHandleTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::VScrollHandleTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; - - __vwsnc115_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_0 = nullptr; - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_1 = nullptr; - ::vl::presentation::compositions::GuiPartialViewComposition* __vwsn_bind_cache_2 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; - - __vwsnc116_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::compositions::GuiPartialViewComposition* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -5041,36 +4917,33 @@ Closures bool Close() override; }; - class __vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; + ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; - __vwsnc117_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); + __vwsnc118_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); - ::darkskin::VScrollTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::VScrollTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); bool Open() override; bool Update() override; bool Close() override; }; - class __vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; + ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; - __vwsnc118_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); + __vwsnc119_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); - ::darkskin::VScrollTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::VScrollTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_1 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; bool __vwsn_bind_opened_ = false; @@ -5083,42 +4956,6 @@ Closures bool Close() override; }; - class __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::VTrackerTemplateConstructor* __vwsnthis_0; - - __vwsnc119_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::VTrackerTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::VTrackerTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_2 = nullptr; - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_3 = nullptr; - ::darkskin::VTrackerTemplate* __vwsn_bind_cache_4 = nullptr; - ::darkskin::VTrackerTemplate* __vwsn_bind_cache_5 = nullptr; - ::darkskin::VTrackerTemplate* __vwsn_bind_cache_6 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_3_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_4_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_5_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_6_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_3_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_4_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_5_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_6_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - class __vwsnc11_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: @@ -5137,12 +4974,159 @@ Closures bool Close() override; }; - class __vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc120_DarkSkin_darkskin_ToolstripSplitButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ToolstripSplitButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::TopScrollButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc121_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::TopScrollButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::TopScrollButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::TopScrollButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc122_DarkSkin_darkskin_TopScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TopScrollButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::TopScrollButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::TopScrollButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::VScrollHandleTemplateConstructor* __vwsnthis_0; + + __vwsnc123_DarkSkin_darkskin_VScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollHandleTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::VScrollHandleTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::VScrollHandleTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; + + __vwsnc124_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::VScrollTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::VScrollTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::VScrollTemplateConstructor* __vwsnthis_0; + + __vwsnc125_DarkSkin_darkskin_VScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VScrollTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::VScrollTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::VScrollTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::VTrackerTemplateConstructor* __vwsnthis_0; + + __vwsnc126_DarkSkin_darkskin_VTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::VTrackerTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::VTrackerTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::VTrackerTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::VTrackerTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - __vwsnc120_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); + __vwsnc127_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); ::darkskin::WindowTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -5155,12 +5139,12 @@ Closures bool Close() override; }; - class __vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::WindowTemplateConstructor* __vwsnthis_0; - __vwsnc121_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); + __vwsnc128_DarkSkin_darkskin_WindowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::WindowTemplateConstructor* __vwsnctorthis_0); ::darkskin::WindowTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -5443,59 +5427,14 @@ Closures bool Close() override; }; - class __vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + ::darkskin::DatePickerTemplateConstructor* __vwsnthis_0; - __vwsnc24_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + __vwsnc24_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0); - ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; - - __vwsnc25_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_2 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; - - __vwsnc26_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::DatePickerTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -5506,46 +5445,73 @@ Closures bool Close() override; }; - class __vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + ::darkskin::DatePickerTemplateConstructor* __vwsnthis_0; - __vwsnc27_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + __vwsnc25_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0); - ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::DatePickerTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); bool Open() override; bool Update() override; bool Close() override; }; - class __vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + ::darkskin::DatePickerTemplateConstructor* __vwsnthis_0; - __vwsnc28_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + __vwsnc26_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0); - ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_2 = nullptr; + ::darkskin::DatePickerTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::DatePickerTemplateConstructor* __vwsnthis_0; + + __vwsnc27_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::DatePickerTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::DatePickerTemplateConstructor* __vwsnthis_0; + + __vwsnc28_DarkSkin_darkskin_DatePickerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::DatePickerTemplateConstructor* __vwsnctorthis_0); + + ::vl::presentation::templates::GuiCommonDatePickerLook* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); bool Open() override; bool Update() override; bool Close() override; @@ -5559,11 +5525,17 @@ Closures __vwsnc29_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_2 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); bool Open() override; bool Update() override; bool Close() override; @@ -5590,12 +5562,114 @@ Closures bool Close() override; }; - class __vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + + __vwsnc30_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + + __vwsnc31_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + + __vwsnc32_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + + __vwsnc33_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnthis_0; + + __vwsnc34_DarkSkin_darkskin_ExpandingDecoratorTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ExpandingDecoratorTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ExpandingDecoratorTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::GroupBoxTemplateConstructor* __vwsnthis_0; - __vwsnc30_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); + __vwsnc35_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -5608,12 +5682,12 @@ Closures bool Close() override; }; - class __vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::GroupBoxTemplateConstructor* __vwsnthis_0; - __vwsnc31_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); + __vwsnc36_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); ::darkskin::GroupBoxTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -5626,12 +5700,12 @@ Closures bool Close() override; }; - class __vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::GroupBoxTemplateConstructor* __vwsnthis_0; - __vwsnc32_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); + __vwsnc37_DarkSkin_darkskin_GroupBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::GroupBoxTemplateConstructor* __vwsnctorthis_0); ::darkskin::GroupBoxTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -5644,12 +5718,12 @@ Closures bool Close() override; }; - class __vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::HScrollHandleTemplateConstructor* __vwsnthis_0; - __vwsnc33_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollHandleTemplateConstructor* __vwsnctorthis_0); + __vwsnc38_DarkSkin_darkskin_HScrollHandleTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollHandleTemplateConstructor* __vwsnctorthis_0); ::darkskin::HScrollHandleTemplate* __vwsn_bind_cache_0 = nullptr; ::darkskin::HScrollHandleTemplate* __vwsn_bind_cache_1 = nullptr; @@ -5665,54 +5739,12 @@ Closures bool Close() override; }; - class __vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; - __vwsnc34_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_0 = nullptr; - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_1 = nullptr; - ::vl::presentation::compositions::GuiPartialViewComposition* __vwsn_bind_cache_2 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; - - __vwsnc35_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::compositions::GuiPartialViewComposition* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; - - __vwsnc36_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); + __vwsnc39_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); ::darkskin::HScrollTemplate* __vwsn_bind_cache_0 = nullptr; ::darkskin::HScrollTemplate* __vwsn_bind_cache_1 = nullptr; @@ -5728,87 +5760,6 @@ Closures bool Close() override; }; - class __vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; - - __vwsnc37_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::HScrollTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::HScrollTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::HTrackerTemplateConstructor* __vwsnthis_0; - - __vwsnc38_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::HTrackerTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::HTrackerTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_2 = nullptr; - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_3 = nullptr; - ::darkskin::HTrackerTemplate* __vwsn_bind_cache_4 = nullptr; - ::darkskin::HTrackerTemplate* __vwsn_bind_cache_5 = nullptr; - ::darkskin::HTrackerTemplate* __vwsn_bind_cache_6 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_3_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_4_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_5_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_6_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_3_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_4_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_5_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_6_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ItemBackgroundTemplateConstructor* __vwsnthis_0; - - __vwsnc39_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ItemBackgroundTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ItemBackgroundTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ItemBackgroundTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::ItemBackgroundTemplate* __vwsn_bind_cache_2 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - class __vwsnc3_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: @@ -5830,12 +5781,81 @@ Closures bool Close() override; }; - class __vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::HScrollTemplateConstructor* __vwsnthis_0; + + __vwsnc40_DarkSkin_darkskin_HScrollTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HScrollTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::HScrollTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::HScrollTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::HTrackerTemplateConstructor* __vwsnthis_0; + + __vwsnc41_DarkSkin_darkskin_HTrackerTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::HTrackerTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::HTrackerTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::HTrackerTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::HTrackerTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ItemBackgroundTemplateConstructor* __vwsnthis_0; + + __vwsnc42_DarkSkin_darkskin_ItemBackgroundTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ItemBackgroundTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ItemBackgroundTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ItemBackgroundTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ItemBackgroundTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::LabelTemplateConstructor* __vwsnthis_0; - __vwsnc40_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); + __vwsnc43_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); ::darkskin::LabelTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -5848,12 +5868,12 @@ Closures bool Close() override; }; - class __vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::LabelTemplateConstructor* __vwsnthis_0; - __vwsnc41_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); + __vwsnc44_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); ::darkskin::LabelTemplate* __vwsn_bind_cache_0 = nullptr; ::darkskin::LabelTemplate* __vwsn_bind_cache_1 = nullptr; @@ -5869,12 +5889,12 @@ Closures bool Close() override; }; - class __vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::LabelTemplateConstructor* __vwsnthis_0; - __vwsnc42_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); + __vwsnc45_DarkSkin_darkskin_LabelTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LabelTemplateConstructor* __vwsnctorthis_0); ::darkskin::LabelTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -5887,12 +5907,12 @@ Closures bool Close() override; }; - class __vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::LeftScrollButtonTemplateConstructor* __vwsnthis_0; - __vwsnc43_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc46_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::LeftScrollButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::darkskin::LeftScrollButtonTemplate* __vwsn_bind_cache_1 = nullptr; @@ -5908,12 +5928,12 @@ Closures bool Close() override; }; - class __vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::LeftScrollButtonTemplateConstructor* __vwsnthis_0; - __vwsnc44_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc47_DarkSkin_darkskin_LeftScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::LeftScrollButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::LeftScrollButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::darkskin::LeftScrollButtonTemplate* __vwsn_bind_cache_1 = nullptr; @@ -5929,69 +5949,6 @@ Closures bool Close() override; }; - class __vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - - __vwsnc45_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_2 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - - __vwsnc46_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - - __vwsnc47_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - class __vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: @@ -6000,11 +5957,17 @@ Closures __vwsnc48_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_2 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); bool Open() override; bool Update() override; bool Close() override; @@ -6018,11 +5981,17 @@ Closures __vwsnc49_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_2 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); bool Open() override; bool Update() override; bool Close() override; @@ -6057,26 +6026,8 @@ Closures __vwsnc50_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::MenuBarButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc51_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_2 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_2 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; @@ -6091,14 +6042,14 @@ Closures bool Close() override; }; - class __vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::MenuBarButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - __vwsnc52_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc51_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); - ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -6109,55 +6060,16 @@ Closures bool Close() override; }; - class __vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::MenuBarButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - __vwsnc53_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc52_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); - ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::MenuBarButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc54_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc55_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_2 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_2 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; @@ -6172,14 +6084,38 @@ Closures bool Close() override; }; - class __vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - __vwsnc56_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc53_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; + + __vwsnc54_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -6190,14 +6126,14 @@ Closures bool Close() override; }; - class __vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - __vwsnc57_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc55_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -6208,14 +6144,35 @@ Closures bool Close() override; }; - class __vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - __vwsnc58_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc56_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; + + __vwsnc57_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -6226,14 +6183,32 @@ Closures bool Close() override; }; - class __vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; - __vwsnc59_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc58_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnthis_0; + + __vwsnc59_DarkSkin_darkskin_ListViewColumnHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ListViewColumnHeaderTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::ListViewColumnHeaderTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -6262,15 +6237,57 @@ Closures bool Close() override; }; - class __vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::MenuBarButtonTemplateConstructor* __vwsnthis_0; - __vwsnc60_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc60_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0); - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::MenuBarButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc61_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::MenuBarButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc62_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_1 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; bool __vwsn_bind_opened_ = false; @@ -6283,14 +6300,14 @@ Closures bool Close() override; }; - class __vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::MenuBarButtonTemplateConstructor* __vwsnthis_0; - __vwsnc61_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc63_DarkSkin_darkskin_MenuBarButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuBarButtonTemplateConstructor* __vwsnctorthis_0); - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::MenuBarButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -6301,45 +6318,6 @@ Closures bool Close() override; }; - class __vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc62_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc63_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - class __vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: @@ -6348,11 +6326,17 @@ Closures __vwsnc64_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_2 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); bool Open() override; bool Update() override; bool Close() override; @@ -6366,17 +6350,11 @@ Closures __vwsnc65_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_2 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); bool Open() override; bool Update() override; bool Close() override; @@ -6390,17 +6368,11 @@ Closures __vwsnc66_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_2 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); bool Open() override; bool Update() override; bool Close() override; @@ -6424,45 +6396,33 @@ Closures bool Close() override; }; - class __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::ProgressBarTemplateConstructor* __vwsnthis_0; + ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; - __vwsnc68_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ProgressBarTemplateConstructor* __vwsnctorthis_0); + __vwsnc68_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_0 = nullptr; - ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_1 = nullptr; - ::darkskin::ProgressBarTemplate* __vwsn_bind_cache_2 = nullptr; - ::darkskin::ProgressBarTemplate* __vwsn_bind_cache_3 = nullptr; - ::darkskin::ProgressBarTemplate* __vwsn_bind_cache_4 = nullptr; + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_3_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_4_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_3_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_4_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); bool Open() override; bool Update() override; bool Close() override; }; - class __vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; - __vwsnc69_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc69_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); - ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_1 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; bool __vwsn_bind_opened_ = false; @@ -6496,12 +6456,183 @@ Closures bool Close() override; }; - class __vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc70_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc71_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc72_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc73_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc74_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc75_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_2 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::MenuItemButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc76_DarkSkin_darkskin_MenuItemButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::MenuItemButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::MenuItemButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::ProgressBarTemplateConstructor* __vwsnthis_0; + + __vwsnc77_DarkSkin_darkskin_ProgressBarTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ProgressBarTemplateConstructor* __vwsnctorthis_0); + + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_0 = nullptr; + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_bind_cache_1 = nullptr; + ::darkskin::ProgressBarTemplate* __vwsn_bind_cache_2 = nullptr; + ::darkskin::ProgressBarTemplate* __vwsn_bind_cache_3 = nullptr; + ::darkskin::ProgressBarTemplate* __vwsn_bind_cache_4 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_3_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_4_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_3_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_4_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; - __vwsnc70_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc78_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_1 = nullptr; @@ -6517,12 +6648,12 @@ Closures bool Close() override; }; - class __vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; - __vwsnc71_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc79_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_1 = nullptr; @@ -6538,156 +6669,6 @@ Closures bool Close() override; }; - class __vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc72_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc73_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc74_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc75_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::RightScrollButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc76_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::RightScrollButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::RightScrollButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::RightScrollButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc77_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::RightScrollButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::RightScrollButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ShortcutKeyTemplateConstructor* __vwsnthis_0; - - __vwsnc78_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ShortcutKeyTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ShortcutKeyTemplateConstructor* __vwsnthis_0; - - __vwsnc79_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ShortcutKeyTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - class __vwsnc7_DarkSkin_darkskin_ButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: @@ -6706,12 +6687,147 @@ Closures bool Close() override; }; - class __vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc80_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc81_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc82_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc83_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::RadioButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc84_DarkSkin_darkskin_RadioButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RadioButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::RadioButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::RightScrollButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc85_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::RightScrollButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::RightScrollButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::RightScrollButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc86_DarkSkin_darkskin_RightScrollButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::RightScrollButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::RightScrollButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::RightScrollButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::ShortcutKeyTemplateConstructor* __vwsnthis_0; - __vwsnc80_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0); + __vwsnc87_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0); ::darkskin::ShortcutKeyTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -6724,35 +6840,14 @@ Closures bool Close() override; }; - class __vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::TabHeaderButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ShortcutKeyTemplateConstructor* __vwsnthis_0; - __vwsnc81_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc88_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0); - ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::TabHeaderButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc82_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ShortcutKeyTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -6763,35 +6858,14 @@ Closures bool Close() override; }; - class __vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::darkskin::TabHeaderButtonTemplateConstructor* __vwsnthis_0; + ::darkskin::ShortcutKeyTemplateConstructor* __vwsnthis_0; - __vwsnc83_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0); + __vwsnc89_DarkSkin_darkskin_ShortcutKeyTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ShortcutKeyTemplateConstructor* __vwsnctorthis_0); - ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::TabHeaderButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc84_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::ShortcutKeyTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -6802,102 +6876,6 @@ Closures bool Close() override; }; - class __vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::TabHeaderTemplateConstructor* __vwsnthis_0; - - __vwsnc85_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::controls::GuiTabPage* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::TabHeaderTemplateConstructor* __vwsnthis_0; - - __vwsnc86_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::controls::GuiTabPage* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::TabHeaderTemplateConstructor* __vwsnthis_0; - - __vwsnc87_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0); - - ::vl::presentation::controls::GuiTab* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::TabTemplateConstructor* __vwsnthis_0; - - __vwsnc88_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::TabTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnthis_0; - - __vwsnc89_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripSplitArrowTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ToolstripSplitArrowTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::ToolstripSplitArrowTemplate* __vwsn_bind_cache_2 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - class __vwsnc8_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: @@ -6919,12 +6897,162 @@ Closures bool Close() override; }; - class __vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::TabHeaderButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc90_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::TabHeaderButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc91_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::TabHeaderButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc92_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_1 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::TabHeaderButtonTemplateConstructor* __vwsnthis_0; + + __vwsnc93_DarkSkin_darkskin_TabHeaderButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderButtonTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::TabHeaderButtonTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::TabHeaderTemplateConstructor* __vwsnthis_0; + + __vwsnc94_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0); + + ::vl::presentation::controls::GuiTabPage* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::TabHeaderTemplateConstructor* __vwsnthis_0; + + __vwsnc95_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0); + + ::vl::presentation::controls::GuiTabPage* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::TabHeaderTemplateConstructor* __vwsnthis_0; + + __vwsnc96_DarkSkin_darkskin_TabHeaderTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabHeaderTemplateConstructor* __vwsnctorthis_0); + + ::vl::presentation::controls::GuiTab* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::darkskin::TabTemplateConstructor* __vwsnthis_0; + + __vwsnc97_DarkSkin_darkskin_TabTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::TabTemplateConstructor* __vwsnctorthis_0); + + ::darkskin::TabTemplate* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnthis_0; - __vwsnc90_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0); + __vwsnc98_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0); ::darkskin::ToolstripSplitArrowTemplate* __vwsn_bind_cache_0 = nullptr; ::darkskin::ToolstripSplitArrowTemplate* __vwsn_bind_cache_1 = nullptr; @@ -6943,12 +7071,12 @@ Closures bool Close() override; }; - class __vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnthis_0; - __vwsnc91_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0); + __vwsnc99_DarkSkin_darkskin_ToolstripSplitArrowTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripSplitArrowTemplateConstructor* __vwsnctorthis_0); ::darkskin::ToolstripSplitArrowTemplate* __vwsn_bind_cache_0 = nullptr; ::darkskin::ToolstripSplitArrowTemplate* __vwsn_bind_cache_1 = nullptr; @@ -6967,168 +7095,6 @@ Closures bool Close() override; }; - class __vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc92_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc93_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_2 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc94_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc95_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc96_DarkSkin_darkskin_ToolstripButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc97_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc98_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_1 = nullptr; - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_2 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_1_0; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_2_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_1_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - void __vwsn_bind_callback_2_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - - class __vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnthis_0; - - __vwsnc99_DarkSkin_darkskin_ToolstripDropdownButtonTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::darkskin::ToolstripDropdownButtonTemplateConstructor* __vwsnctorthis_0); - - ::darkskin::ToolstripDropdownButtonTemplate* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - class __vwsnc9_DarkSkin_darkskin_CheckBoxTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: diff --git a/Import/Skins/DarkSkin/DarkSkinReflection.cpp b/Import/Skins/DarkSkin/DarkSkinReflection.cpp index b809e40d..cfc6e00f 100644 --- a/Import/Skins/DarkSkin/DarkSkinReflection.cpp +++ b/Import/Skins/DarkSkin/DarkSkinReflection.cpp @@ -39,7 +39,6 @@ namespace vl namespace description { #ifndef VCZH_DEBUG_NO_REFLECTION - IMPL_CPP_TYPE_INFO(ScrollTemplateScript) IMPL_CPP_TYPE_INFO(darkskin::BottomScrollButtonTemplate) IMPL_CPP_TYPE_INFO(darkskin::BottomScrollButtonTemplateConstructor) IMPL_CPP_TYPE_INFO(darkskin::ButtonTemplate) @@ -140,11 +139,6 @@ namespace vl IMPL_CPP_TYPE_INFO(darkskin::WindowTemplateConstructor) #define _ , - BEGIN_CLASS_MEMBER(::ScrollTemplateScript) - CLASS_MEMBER_CONSTRUCTOR(::vl::Ptr<::ScrollTemplateScript>(), NO_PARAMETER) - CLASS_MEMBER_STATIC_METHOD(SetScroll, { L"totalPixels" _ L"newOffset" _ L"scrollTemplate" }) - END_CLASS_MEMBER(::ScrollTemplateScript) - BEGIN_CLASS_MEMBER(::darkskin::BottomScrollButtonTemplate) CLASS_MEMBER_CONSTRUCTOR(::darkskin::BottomScrollButtonTemplate*(), NO_PARAMETER) END_CLASS_MEMBER(::darkskin::BottomScrollButtonTemplate) @@ -243,6 +237,7 @@ namespace vl BEGIN_CLASS_MEMBER(::darkskin::DatePickerTemplateConstructor) CLASS_MEMBER_CONSTRUCTOR(::vl::Ptr<::darkskin::DatePickerTemplateConstructor>(), NO_PARAMETER) CLASS_MEMBER_METHOD(__vwsn_initialize_instance_, { L"__vwsn_this_" }) + CLASS_MEMBER_FIELD(look) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::DatePickerTemplateConstructor) @@ -278,7 +273,8 @@ namespace vl CLASS_MEMBER_METHOD(__vwsn_initialize_instance_, { L"__vwsn_this_" }) CLASS_MEMBER_FIELD(__vwsn_precompile_0) CLASS_MEMBER_FIELD(__vwsn_precompile_1) - CLASS_MEMBER_FIELD(container) + CLASS_MEMBER_FIELD(__vwsn_precompile_2) + CLASS_MEMBER_FIELD(look) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::DocumentViewerTemplateConstructor) @@ -330,8 +326,7 @@ namespace vl BEGIN_CLASS_MEMBER(::darkskin::HScrollTemplate) CLASS_MEMBER_CONSTRUCTOR(::darkskin::HScrollTemplate*(), NO_PARAMETER) - CLASS_MEMBER_FIELD(draggingHandle) - CLASS_MEMBER_FIELD(draggingStartLocation) + CLASS_MEMBER_METHOD(__vwsn_instance_ctor_, NO_PARAMETER) END_CLASS_MEMBER(::darkskin::HScrollTemplate) BEGIN_CLASS_MEMBER(::darkskin::HScrollTemplateConstructor) @@ -339,25 +334,22 @@ namespace vl CLASS_MEMBER_METHOD(__vwsn_initialize_instance_, { L"__vwsn_this_" }) CLASS_MEMBER_FIELD(__vwsn_precompile_0) CLASS_MEMBER_FIELD(__vwsn_precompile_1) - CLASS_MEMBER_FIELD(__vwsn_precompile_10) CLASS_MEMBER_FIELD(__vwsn_precompile_2) CLASS_MEMBER_FIELD(__vwsn_precompile_3) CLASS_MEMBER_FIELD(__vwsn_precompile_4) CLASS_MEMBER_FIELD(__vwsn_precompile_5) CLASS_MEMBER_FIELD(__vwsn_precompile_6) - CLASS_MEMBER_FIELD(__vwsn_precompile_7) - CLASS_MEMBER_FIELD(__vwsn_precompile_8) - CLASS_MEMBER_FIELD(__vwsn_precompile_9) + CLASS_MEMBER_FIELD(behavior) + CLASS_MEMBER_FIELD(buttonDecrease) + CLASS_MEMBER_FIELD(buttonIncrease) CLASS_MEMBER_FIELD(handle) CLASS_MEMBER_FIELD(handleContainer) - CLASS_MEMBER_FIELD(invalidContainer) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::HScrollTemplateConstructor) BEGIN_CLASS_MEMBER(::darkskin::HTrackerTemplate) CLASS_MEMBER_CONSTRUCTOR(::darkskin::HTrackerTemplate*(), NO_PARAMETER) - CLASS_MEMBER_FIELD(draggingHandle) - CLASS_MEMBER_FIELD(draggingStartLocation) + CLASS_MEMBER_METHOD(__vwsn_instance_ctor_, NO_PARAMETER) END_CLASS_MEMBER(::darkskin::HTrackerTemplate) BEGIN_CLASS_MEMBER(::darkskin::HTrackerTemplateConstructor) @@ -371,8 +363,8 @@ namespace vl CLASS_MEMBER_FIELD(__vwsn_precompile_5) CLASS_MEMBER_FIELD(__vwsn_precompile_6) CLASS_MEMBER_FIELD(__vwsn_precompile_7) + CLASS_MEMBER_FIELD(behavior) CLASS_MEMBER_FIELD(handle) - CLASS_MEMBER_FIELD(invalidContainer) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::HTrackerTemplateConstructor) @@ -421,6 +413,11 @@ namespace vl CLASS_MEMBER_METHOD(__vwsn_initialize_instance_, { L"__vwsn_this_" }) CLASS_MEMBER_FIELD(__vwsn_precompile_0) CLASS_MEMBER_FIELD(__vwsn_precompile_1) + CLASS_MEMBER_FIELD(__vwsn_precompile_10) + CLASS_MEMBER_FIELD(__vwsn_precompile_11) + CLASS_MEMBER_FIELD(__vwsn_precompile_12) + CLASS_MEMBER_FIELD(__vwsn_precompile_13) + CLASS_MEMBER_FIELD(__vwsn_precompile_14) CLASS_MEMBER_FIELD(__vwsn_precompile_2) CLASS_MEMBER_FIELD(__vwsn_precompile_3) CLASS_MEMBER_FIELD(__vwsn_precompile_4) @@ -430,6 +427,7 @@ namespace vl CLASS_MEMBER_FIELD(__vwsn_precompile_8) CLASS_MEMBER_FIELD(__vwsn_precompile_9) CLASS_MEMBER_FIELD(buttonArrow) + CLASS_MEMBER_FIELD(container) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::ListViewColumnHeaderTemplateConstructor) @@ -442,7 +440,8 @@ namespace vl CLASS_MEMBER_METHOD(__vwsn_initialize_instance_, { L"__vwsn_this_" }) CLASS_MEMBER_FIELD(__vwsn_precompile_0) CLASS_MEMBER_FIELD(__vwsn_precompile_1) - CLASS_MEMBER_FIELD(container) + CLASS_MEMBER_FIELD(__vwsn_precompile_2) + CLASS_MEMBER_FIELD(look) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::ListViewTemplateConstructor) @@ -503,7 +502,8 @@ namespace vl CLASS_MEMBER_METHOD(__vwsn_initialize_instance_, { L"__vwsn_this_" }) CLASS_MEMBER_FIELD(__vwsn_precompile_0) CLASS_MEMBER_FIELD(__vwsn_precompile_1) - CLASS_MEMBER_FIELD(container) + CLASS_MEMBER_FIELD(__vwsn_precompile_2) + CLASS_MEMBER_FIELD(look) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::MultilineTextBoxTemplateConstructor) @@ -567,6 +567,7 @@ namespace vl CLASS_MEMBER_FIELD(__vwsn_precompile_0) CLASS_MEMBER_FIELD(__vwsn_precompile_1) CLASS_MEMBER_FIELD(__vwsn_precompile_2) + CLASS_MEMBER_FIELD(look) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::ScrollViewTemplateConstructor) @@ -661,7 +662,8 @@ namespace vl CLASS_MEMBER_METHOD(__vwsn_initialize_instance_, { L"__vwsn_this_" }) CLASS_MEMBER_FIELD(__vwsn_precompile_0) CLASS_MEMBER_FIELD(__vwsn_precompile_1) - CLASS_MEMBER_FIELD(container) + CLASS_MEMBER_FIELD(__vwsn_precompile_2) + CLASS_MEMBER_FIELD(look) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::TextListTemplateConstructor) @@ -819,7 +821,8 @@ namespace vl CLASS_MEMBER_METHOD(__vwsn_initialize_instance_, { L"__vwsn_this_" }) CLASS_MEMBER_FIELD(__vwsn_precompile_0) CLASS_MEMBER_FIELD(__vwsn_precompile_1) - CLASS_MEMBER_FIELD(container) + CLASS_MEMBER_FIELD(__vwsn_precompile_2) + CLASS_MEMBER_FIELD(look) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::TreeViewTemplateConstructor) @@ -837,8 +840,7 @@ namespace vl BEGIN_CLASS_MEMBER(::darkskin::VScrollTemplate) CLASS_MEMBER_CONSTRUCTOR(::darkskin::VScrollTemplate*(), NO_PARAMETER) - CLASS_MEMBER_FIELD(draggingHandle) - CLASS_MEMBER_FIELD(draggingStartLocation) + CLASS_MEMBER_METHOD(__vwsn_instance_ctor_, NO_PARAMETER) END_CLASS_MEMBER(::darkskin::VScrollTemplate) BEGIN_CLASS_MEMBER(::darkskin::VScrollTemplateConstructor) @@ -846,25 +848,22 @@ namespace vl CLASS_MEMBER_METHOD(__vwsn_initialize_instance_, { L"__vwsn_this_" }) CLASS_MEMBER_FIELD(__vwsn_precompile_0) CLASS_MEMBER_FIELD(__vwsn_precompile_1) - CLASS_MEMBER_FIELD(__vwsn_precompile_10) CLASS_MEMBER_FIELD(__vwsn_precompile_2) CLASS_MEMBER_FIELD(__vwsn_precompile_3) CLASS_MEMBER_FIELD(__vwsn_precompile_4) CLASS_MEMBER_FIELD(__vwsn_precompile_5) CLASS_MEMBER_FIELD(__vwsn_precompile_6) - CLASS_MEMBER_FIELD(__vwsn_precompile_7) - CLASS_MEMBER_FIELD(__vwsn_precompile_8) - CLASS_MEMBER_FIELD(__vwsn_precompile_9) + CLASS_MEMBER_FIELD(behavior) + CLASS_MEMBER_FIELD(buttonDecrease) + CLASS_MEMBER_FIELD(buttonIncrease) CLASS_MEMBER_FIELD(handle) CLASS_MEMBER_FIELD(handleContainer) - CLASS_MEMBER_FIELD(invalidContainer) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::VScrollTemplateConstructor) BEGIN_CLASS_MEMBER(::darkskin::VTrackerTemplate) CLASS_MEMBER_CONSTRUCTOR(::darkskin::VTrackerTemplate*(), NO_PARAMETER) - CLASS_MEMBER_FIELD(draggingHandle) - CLASS_MEMBER_FIELD(draggingStartLocation) + CLASS_MEMBER_METHOD(__vwsn_instance_ctor_, NO_PARAMETER) END_CLASS_MEMBER(::darkskin::VTrackerTemplate) BEGIN_CLASS_MEMBER(::darkskin::VTrackerTemplateConstructor) @@ -878,8 +877,8 @@ namespace vl CLASS_MEMBER_FIELD(__vwsn_precompile_5) CLASS_MEMBER_FIELD(__vwsn_precompile_6) CLASS_MEMBER_FIELD(__vwsn_precompile_7) + CLASS_MEMBER_FIELD(behavior) CLASS_MEMBER_FIELD(handle) - CLASS_MEMBER_FIELD(invalidContainer) CLASS_MEMBER_FIELD(self) END_CLASS_MEMBER(::darkskin::VTrackerTemplateConstructor) @@ -925,7 +924,6 @@ namespace vl public: void Load(ITypeManager* manager) { - ADD_TYPE_INFO(::ScrollTemplateScript) ADD_TYPE_INFO(::darkskin::BottomScrollButtonTemplate) ADD_TYPE_INFO(::darkskin::BottomScrollButtonTemplateConstructor) ADD_TYPE_INFO(::darkskin::ButtonTemplate) diff --git a/Import/Skins/DarkSkin/DarkSkinReflection.h b/Import/Skins/DarkSkin/DarkSkinReflection.h index 115559a3..2737f4ff 100644 --- a/Import/Skins/DarkSkin/DarkSkinReflection.h +++ b/Import/Skins/DarkSkin/DarkSkinReflection.h @@ -47,7 +47,6 @@ namespace vl namespace description { #ifndef VCZH_DEBUG_NO_REFLECTION - DECL_TYPE_INFO(::ScrollTemplateScript) DECL_TYPE_INFO(::darkskin::BottomScrollButtonTemplate) DECL_TYPE_INFO(::darkskin::BottomScrollButtonTemplateConstructor) DECL_TYPE_INFO(::darkskin::ButtonTemplate) diff --git a/Import/Vlpp.cpp b/Import/Vlpp.cpp index 056e1e6f..264a59b5 100644 --- a/Import/Vlpp.cpp +++ b/Import/Vlpp.cpp @@ -11714,6 +11714,7 @@ TypedValueSerializerProvider bool TypedValueSerializerProvider::Serialize(const float& input, WString& output) { output = ftow(input); + if (output == L"-0") output = L"0"; return true; } @@ -11737,6 +11738,7 @@ TypedValueSerializerProvider bool TypedValueSerializerProvider::Serialize(const double& input, WString& output) { output = ftow(input); + if (output == L"-0") output = L"0"; return true; } diff --git a/Import/Vlpp.h b/Import/Vlpp.h index bd3315a3..e452748f 100644 --- a/Import/Vlpp.h +++ b/Import/Vlpp.h @@ -5023,7 +5023,7 @@ namespace vl { for(vint i = 0; i < handlers.Count(); i++) { - handlers[i]->function(ForwardValue(args)...); + handlers[i]->function(args...); } } }; diff --git a/Tools/CppMerge.exe b/Tools/CppMerge.exe index e8dd090a..c3e7b548 100644 Binary files a/Tools/CppMerge.exe and b/Tools/CppMerge.exe differ diff --git a/Tools/GacGen.ps1 b/Tools/GacGen.ps1 index 9fe3ade9..53d06deb 100644 --- a/Tools/GacGen.ps1 +++ b/Tools/GacGen.ps1 @@ -1,8 +1,12 @@ param ( [String]$FileName ) + +. $PSScriptRoot\StartProcess.ps1 + Write-Host "Compiling GacUI Resource: $FileName ..." -Start-Process-And-Wait (("$PSScriptRoot\GacGen32.exe", "/P $FileName"), ("$PSScriptRoot\GacGen64.exe", "/P $FileName")) +Start-Process-And-Wait (,("$PSScriptRoot\GacGen32.exe", "/P $FileName")) +Start-Process-And-Wait (,("$PSScriptRoot\GacGen64.exe", "/P $FileName")) if (Test-Path -Path "$($FileName).log\x32\Error.txt") { throw "Failed to compile GacUI Resource (x86): $FileName" @@ -25,5 +29,5 @@ Get-ChildItem -Path $x32_folder -ErrorAction SilentlyContinue | %{ $deploy = "$($FileName).log\x32\Deploy.bat" if (Test-Path -Path $deploy) { Write-Host " Deploying ..." - Start-Process-And-Wait (,($env:ComSpec, "/c `"$deploy`"")) + Start-Process-And-Wait (,($env:ComSpec, "/c `"$deploy`"")) $true } \ No newline at end of file diff --git a/Tools/GacGen32.exe b/Tools/GacGen32.exe index 64d73a1d..f055de85 100644 Binary files a/Tools/GacGen32.exe and b/Tools/GacGen32.exe differ diff --git a/Tools/GacGen64.exe b/Tools/GacGen64.exe index 8c47db23..7d4d169a 100644 Binary files a/Tools/GacGen64.exe and b/Tools/GacGen64.exe differ diff --git a/Tools/StartProcess.ps1 b/Tools/StartProcess.ps1 new file mode 100644 index 00000000..2cc21884 --- /dev/null +++ b/Tools/StartProcess.ps1 @@ -0,0 +1,36 @@ +function Start-Process-And-Wait([String[][]] $Pairs, [Boolean]$Inline = $false, [String]$workingDirectory = "") { + $processes = New-Object System.Diagnostics.Process[] $Pairs.Length + for ($i = 0; $i -lt $Pairs.Length; $i++) { + Write-Host " Running: $($Pairs[$i][0]) $($Pairs[$i][1])" -ForegroundColor DarkGray + + $arguments = @{}; + if ($Pairs[$i][1] -ne "") { + $arguments.Add("ArgumentList", $Pairs[$i][1]) + } + $arguments.Add("PassThru", $true) + $arguments.Add("NoNewWindow", $Inline) + if ($workingDirectory -ne "") { + $arguments.Add("WorkingDirectory", $workingDirectory) + } + + $processes[$i] = Start-Process $Pairs[$i][0] @arguments + } + + $failed = $false + for ($i = 0; $i -lt $Pairs.Length; $i++) { + $process = $processes[$i] + $process_handle = $process.Handle + $process.WaitForExit() + if ($process.ExitCode -ne 0) { + Write-Host " Crashes($($process.ExitCode)): $($Pairs[$i][0]) $($Pairs[$i][1])" -ForegroundColor Red + $failed = $true + } + $process.Close() + } + + [Console]::ResetColor() + + if ($failed) { + throw "One or more processes crash" + } +} \ No newline at end of file diff --git a/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/RepeatTabPage.xml b/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/RepeatTabPage.xml index db9471af..e18b53f9 100644 --- a/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/RepeatTabPage.xml +++ b/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/RepeatTabPage.xml @@ -74,10 +74,13 @@ <_>composeType:Percentage percentage:1.0 + <_>composeType:Absolute absolute:20 + <_>composeType:Absolute absolute:20 <_>composeType:Percentage percentage:0.5 <_>composeType:MinSize + <_>composeType:Absolute absolute:20 @@ -181,6 +184,24 @@ + + + + + + + + + + + + + + + + + +
\ No newline at end of file diff --git a/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoPartialClasses.cpp b/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoPartialClasses.cpp index f9cce9b2..3f58efb9 100644 --- a/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoPartialClasses.cpp +++ b/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoPartialClasses.cpp @@ -430,12 +430,30 @@ Closures //------------------------------------------------------------------- - __vwsnf100_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::__vwsnf100_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0) + __vwsnf100_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__::__vwsnf100_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__(::demo::RepeatTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - bool __vwsnf100_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_item_, bool __vwsn_value_, bool __vwsn_update_) const + void __vwsnf100_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_27)->GetPosition(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::vint>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_27)->SetPosition(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::__vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + bool __vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_item_, bool __vwsn_value_, bool __vwsn_update_) const { auto item = ::vl::__vwsn::Unbox<::vl::Ptr<::demo::MyTextItem>>(__vwsn_item_); if (__vwsn_update_) @@ -451,12 +469,12 @@ Closures //------------------------------------------------------------------- - __vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::__vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0) + __vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::__vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - ::vl::WString __vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_item_) const + ::vl::WString __vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_item_) const { auto item = ::vl::__vwsn::Unbox<::vl::Ptr<::demo::MyTextItem>>(__vwsn_item_); return ::vl::__vwsn::This(item.Obj())->GetName(); @@ -464,12 +482,12 @@ Closures //------------------------------------------------------------------- - __vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::__vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0) + __vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::__vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + void __vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const { { auto __vwsn_switch_5 = ::vl::__vwsn::This(__vwsnthis_0->comboView)->GetSelectedIndex(); @@ -493,12 +511,12 @@ Closures //------------------------------------------------------------------- - __vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::__vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0) + __vwsnf104_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::__vwsnf104_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + void __vwsnf104_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const { { auto __vwsn_for_begin_i = static_cast<::vl::vint>(0); @@ -532,33 +550,6 @@ Closures //------------------------------------------------------------------- - __vwsnf104_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::__vwsnf104_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf104_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const - { - { - auto i = static_cast<::vl::vint>(0); - while ((i < ::vl::__vwsn::This(::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueList>(::vl::__vwsn::This(__vwsnthis_0->textList)->GetItems()).Obj())->GetCount())) - { - ::vl::__vwsn::This(::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueList>(::vl::__vwsn::This(__vwsnthis_0->textList)->GetItems()).Obj())->RemoveAt(i); - (i = (i + static_cast<::vl::vint>(1))); - } - } - { - auto i = static_cast<::vl::vint>(0); - while ((i < ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->itemsToBind.Obj())->GetCount())) - { - ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->itemsToBind.Obj())->RemoveAt(i); - (i = (i + static_cast<::vl::vint>(1))); - } - } - } - - //------------------------------------------------------------------- - __vwsnf105_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::__vwsnf105_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -567,7 +558,7 @@ Closures void __vwsnf105_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const { { - auto i = static_cast<::vl::vint>(1); + auto i = static_cast<::vl::vint>(0); while ((i < ::vl::__vwsn::This(::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueList>(::vl::__vwsn::This(__vwsnthis_0->textList)->GetItems()).Obj())->GetCount())) { ::vl::__vwsn::This(::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueList>(::vl::__vwsn::This(__vwsnthis_0->textList)->GetItems()).Obj())->RemoveAt(i); @@ -575,7 +566,7 @@ Closures } } { - auto i = static_cast<::vl::vint>(1); + auto i = static_cast<::vl::vint>(0); while ((i < ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->itemsToBind.Obj())->GetCount())) { ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->itemsToBind.Obj())->RemoveAt(i); @@ -593,21 +584,35 @@ Closures void __vwsnf106_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const { - ::vl::__vwsn::This(::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueList>(::vl::__vwsn::This(__vwsnthis_0->textList)->GetItems()).Obj())->Clear(); - ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->itemsToBind.Obj())->Clear(); + { + auto i = static_cast<::vl::vint>(1); + while ((i < ::vl::__vwsn::This(::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueList>(::vl::__vwsn::This(__vwsnthis_0->textList)->GetItems()).Obj())->GetCount())) + { + ::vl::__vwsn::This(::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueList>(::vl::__vwsn::This(__vwsnthis_0->textList)->GetItems()).Obj())->RemoveAt(i); + (i = (i + static_cast<::vl::vint>(1))); + } + } + { + auto i = static_cast<::vl::vint>(1); + while ((i < ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->itemsToBind.Obj())->GetCount())) + { + ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->itemsToBind.Obj())->RemoveAt(i); + (i = (i + static_cast<::vl::vint>(1))); + } + } } //------------------------------------------------------------------- - __vwsnf107_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__::__vwsnf107_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(::demo::TreeViewTabPageConstructor* __vwsnctorthis_0) + __vwsnf107_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::__vwsnf107_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - ::vl::Ptr<::vl::reflection::description::IValueEnumerable> __vwsnf107_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_item_) const + void __vwsnf107_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const { - auto nodeToBind = ::vl::__vwsn::Unbox<::vl::Ptr<::vl::presentation::controls::tree::MemoryNodeProvider>>(__vwsn_item_); - return ::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueEnumerable>(::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueList>(::vl::__vwsn::This(nodeToBind.Obj())->Children())); + ::vl::__vwsn::This(::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueList>(::vl::__vwsn::This(__vwsnthis_0->textList)->GetItems()).Obj())->Clear(); + ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->itemsToBind.Obj())->Clear(); } //------------------------------------------------------------------- @@ -617,10 +622,10 @@ Closures { } - ::vl::Ptr<::vl::presentation::GuiImageData> __vwsnf108_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_item_) const + ::vl::Ptr<::vl::reflection::description::IValueEnumerable> __vwsnf108_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_item_) const { auto nodeToBind = ::vl::__vwsn::Unbox<::vl::Ptr<::vl::presentation::controls::tree::MemoryNodeProvider>>(__vwsn_item_); - return ::vl::__vwsn::This(::vl::__vwsn::SharedPtrCast<::vl::presentation::controls::tree::TreeViewItem>(::vl::__vwsn::This(nodeToBind.Obj())->GetData().Obj()).Obj())->image; + return ::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueEnumerable>(::vl::__vwsn::UnboxCollection<::vl::reflection::description::IValueList>(::vl::__vwsn::This(nodeToBind.Obj())->Children())); } //------------------------------------------------------------------- @@ -630,10 +635,10 @@ Closures { } - ::vl::WString __vwsnf109_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_item_) const + ::vl::Ptr<::vl::presentation::GuiImageData> __vwsnf109_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_item_) const { auto nodeToBind = ::vl::__vwsn::Unbox<::vl::Ptr<::vl::presentation::controls::tree::MemoryNodeProvider>>(__vwsn_item_); - return ::vl::__vwsn::This(::vl::__vwsn::SharedPtrCast<::vl::presentation::controls::tree::TreeViewItem>(::vl::__vwsn::This(nodeToBind.Obj())->GetData().Obj()).Obj())->text; + return ::vl::__vwsn::This(::vl::__vwsn::SharedPtrCast<::vl::presentation::controls::tree::TreeViewItem>(::vl::__vwsn::This(nodeToBind.Obj())->GetData().Obj()).Obj())->image; } //------------------------------------------------------------------- @@ -652,12 +657,25 @@ Closures //------------------------------------------------------------------- - __vwsnf110_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__::__vwsnf110_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__(::demo::DateEditorConstructor* __vwsnctorthis_0) + __vwsnf110_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__::__vwsnf110_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(::demo::TreeViewTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf110_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + ::vl::WString __vwsnf110_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_item_) const + { + auto nodeToBind = ::vl::__vwsn::Unbox<::vl::Ptr<::vl::presentation::controls::tree::MemoryNodeProvider>>(__vwsn_item_); + return ::vl::__vwsn::This(::vl::__vwsn::SharedPtrCast<::vl::presentation::controls::tree::TreeViewItem>(::vl::__vwsn::This(nodeToBind.Obj())->GetData().Obj()).Obj())->text; + } + + //------------------------------------------------------------------- + + __vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__::__vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__(::demo::DateEditorConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->comboBox)->GetSelectedDate(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::DateTime>(__vwsn_value_); @@ -670,12 +688,12 @@ Closures //------------------------------------------------------------------- - __vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__::__vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__(::demo::DateEditorConstructor* __vwsnctorthis_0) + __vwsnf112_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__::__vwsnf112_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__(::demo::DateEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf112_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->self)->GetCellValue(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::reflection::description::Value>(__vwsn_value_); @@ -688,32 +706,14 @@ Closures //------------------------------------------------------------------- - __vwsnf112_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::__vwsnf112_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(::demo::DateFilterConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf112_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const - { - ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateFilter(); - } - - //------------------------------------------------------------------- - __vwsnf113_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::__vwsnf113_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(::demo::DateFilterConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf113_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf113_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->dateFrom)->GetEnabled(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->dateFrom)->SetEnabled(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateFilter(); } //------------------------------------------------------------------- @@ -723,9 +723,15 @@ Closures { } - void __vwsnf114_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + void __vwsnf114_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateFilter(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->dateFrom)->GetEnabled(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->dateFrom)->SetEnabled(__vwsn_new_); } //------------------------------------------------------------------- @@ -747,7 +753,19 @@ Closures { } - void __vwsnf116_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf116_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + { + ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateFilter(); + } + + //------------------------------------------------------------------- + + __vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::__vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(::demo::DateFilterConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->dateTo)->GetEnabled(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -760,36 +778,18 @@ Closures //------------------------------------------------------------------- - __vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::__vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(::demo::DateFilterConstructor* __vwsnctorthis_0) + __vwsnf118_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::__vwsnf118_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(::demo::DateFilterConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + void __vwsnf118_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const { ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateFilter(); } //------------------------------------------------------------------- - __vwsnf118_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__::__vwsnf118_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__(::demo::TextEditorConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf118_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->textBox)->GetText(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->textBox)->SetText(__vwsn_new_); - } - - //------------------------------------------------------------------- - __vwsnf119_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__::__vwsnf119_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__(::demo::TextEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -797,13 +797,13 @@ Closures void __vwsnf119_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->self)->GetCellValue(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::reflection::description::Value>(__vwsn_value_); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->textBox)->GetText(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->self)->SetCellValue(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->textBox)->SetText(__vwsn_new_); } //------------------------------------------------------------------- @@ -829,120 +829,12 @@ Closures //------------------------------------------------------------------- - __vwsnf120_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::__vwsnf120_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0) + __vwsnf120_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__::__vwsnf120_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__(::demo::TextEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf120_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetColor(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->SetColor(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf121_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::__vwsnf121_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf121_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->GetText(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->SetText(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf122_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::__vwsnf122_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf122_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->GetFont(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->SetFont(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf123_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::__vwsnf123_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiListItemTemplate* __vwsnf123_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - if ((dynamic_cast<::vl::reflection::description::IValueType::TypedBox<::demo::MyCategory>*>(__vwsn_viewModel_.GetBoxedValue().Obj()) != nullptr)) - { - return static_cast<::vl::presentation::templates::GuiListItemTemplate*>(new ::demo::CategoryItemTemplate(::vl::__vwsn::Unbox<::demo::MyCategory>(__vwsn_viewModel_))); - } - } - throw ::vl::Exception(::vl::WString(L"Cannot find a matched control template to create.", false)); - } - - //------------------------------------------------------------------- - - __vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::__vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - ::vl::presentation::templates::GuiTemplate* __vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const - { - { - if ((dynamic_cast<::vl::reflection::description::IValueType::TypedBox<::demo::MyCategory>*>(__vwsn_viewModel_.GetBoxedValue().Obj()) != nullptr)) - { - return static_cast<::vl::presentation::templates::GuiTemplate*>(new ::demo::CategoryItemTemplate(::vl::__vwsn::Unbox<::demo::MyCategory>(__vwsn_viewModel_))); - } - } - throw ::vl::Exception(::vl::WString(L"Cannot find a matched control template to create.", false)); - } - - //------------------------------------------------------------------- - - __vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::__vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const - { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->comboBox)->GetSelectedIndex(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::vint>(__vwsn_value_); - if ((__vwsn_old_ == __vwsn_new_)) - { - return; - } - ::vl::__vwsn::This(__vwsnthis_0->comboBox)->SetSelectedIndex(__vwsn_new_); - } - - //------------------------------------------------------------------- - - __vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::__vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf120_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->self)->GetCellValue(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::reflection::description::Value>(__vwsn_value_); @@ -955,30 +847,138 @@ Closures //------------------------------------------------------------------- - __vwsnf127_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__::__vwsnf127_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__(::demo::CategoryItemTemplateConstructor* __vwsnctorthis_0) + __vwsnf121_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::__vwsnf121_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf127_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf121_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->GetFont(); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->GetColor(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::Color>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_4.Obj())->SetColor(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf122_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::__vwsnf122_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf122_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->GetText(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->SetText(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf123_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::__vwsnf123_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf123_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->GetFont(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->SetFont(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_6.Obj())->SetFont(__vwsn_new_); } //------------------------------------------------------------------- - __vwsnf128_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__::__vwsnf128_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__(::demo::CategoryVisualizerConstructor* __vwsnctorthis_0) + __vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::__vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf128_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + ::vl::presentation::templates::GuiListItemTemplate* __vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + { + { + if ((dynamic_cast<::vl::reflection::description::IValueType::TypedBox<::demo::MyCategory>*>(__vwsn_viewModel_.GetBoxedValue().Obj()) != nullptr)) + { + return static_cast<::vl::presentation::templates::GuiListItemTemplate*>(new ::demo::CategoryItemTemplate(::vl::__vwsn::Unbox<::demo::MyCategory>(__vwsn_viewModel_))); + } + } + throw ::vl::Exception(::vl::WString(L"Cannot find a matched control template to create.", false)); + } + + //------------------------------------------------------------------- + + __vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::__vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + ::vl::presentation::templates::GuiTemplate* __vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + { + { + if ((dynamic_cast<::vl::reflection::description::IValueType::TypedBox<::demo::MyCategory>*>(__vwsn_viewModel_.GetBoxedValue().Obj()) != nullptr)) + { + return static_cast<::vl::presentation::templates::GuiTemplate*>(new ::demo::CategoryItemTemplate(::vl::__vwsn::Unbox<::demo::MyCategory>(__vwsn_viewModel_))); + } + } + throw ::vl::Exception(::vl::WString(L"Cannot find a matched control template to create.", false)); + } + + //------------------------------------------------------------------- + + __vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::__vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->comboBox)->GetSelectedIndex(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::vint>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->comboBox)->SetSelectedIndex(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf127_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::__vwsnf127_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf127_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->self)->GetCellValue(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::reflection::description::Value>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->self)->SetCellValue(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf128_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__::__vwsnf128_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__(::demo::CategoryItemTemplateConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf128_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->GetFont(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); @@ -998,13 +998,13 @@ Closures void __vwsnf129_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { - auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->GetCategory(); - auto __vwsn_new_ = ::vl::__vwsn::Unbox<::demo::MyCategory>(__vwsn_value_); + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->GetFont(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::presentation::FontProperties>(__vwsn_value_); if ((__vwsn_old_ == __vwsn_new_)) { return; } - ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->SetCategory(__vwsn_new_); + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->SetFont(__vwsn_new_); } //------------------------------------------------------------------- @@ -1022,12 +1022,30 @@ Closures //------------------------------------------------------------------- - __vwsnf130_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__::__vwsnf130_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__(::demo::GenderDisplayerConstructor* __vwsnctorthis_0) + __vwsnf130_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__::__vwsnf130_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__(::demo::CategoryVisualizerConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf130_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf130_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + { + auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->GetCategory(); + auto __vwsn_new_ = ::vl::__vwsn::Unbox<::demo::MyCategory>(__vwsn_value_); + if ((__vwsn_old_ == __vwsn_new_)) + { + return; + } + ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->SetCategory(__vwsn_new_); + } + + //------------------------------------------------------------------- + + __vwsnf131_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__::__vwsnf131_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__(::demo::GenderDisplayerConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf131_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1.Obj())->GetImage(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::Ptr<::vl::presentation::INativeImage>>(__vwsn_value_); @@ -1040,12 +1058,12 @@ Closures //------------------------------------------------------------------- - __vwsnf131_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::__vwsnf131_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0) + __vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::__vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - ::vl::presentation::templates::GuiListItemTemplate* __vwsnf131_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + ::vl::presentation::templates::GuiListItemTemplate* __vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { if ((dynamic_cast<::vl::reflection::description::IValueType::TypedBox<::demo::MyGender>*>(__vwsn_viewModel_.GetBoxedValue().Obj()) != nullptr)) @@ -1058,12 +1076,12 @@ Closures //------------------------------------------------------------------- - __vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::__vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0) + __vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::__vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - ::vl::presentation::templates::GuiTemplate* __vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const + ::vl::presentation::templates::GuiTemplate* __vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const { { if ((dynamic_cast<::vl::reflection::description::IValueType::TypedBox<::demo::MyGender>*>(__vwsn_viewModel_.GetBoxedValue().Obj()) != nullptr)) @@ -1076,12 +1094,12 @@ Closures //------------------------------------------------------------------- - __vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::__vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0) + __vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::__vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->comboBox)->GetSelectedIndex(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::vint>(__vwsn_value_); @@ -1094,12 +1112,12 @@ Closures //------------------------------------------------------------------- - __vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::__vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0) + __vwsnf135_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::__vwsnf135_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf135_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->self)->GetCellValue(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::reflection::description::Value>(__vwsn_value_); @@ -1112,12 +1130,12 @@ Closures //------------------------------------------------------------------- - __vwsnf135_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__::__vwsnf135_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__(::demo::GenderVisualizerConstructor* __vwsnctorthis_0) + __vwsnf136_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__::__vwsnf136_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__(::demo::GenderVisualizerConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf135_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf136_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_0)->GetGender(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::demo::MyGender>(__vwsn_value_); @@ -1130,25 +1148,25 @@ Closures //------------------------------------------------------------------- - __vwsnf136_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__::__vwsnf136_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__(::demo::HyperlinkWindowConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf136_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const - { - ::vl::__vwsn::This(__vwsnthis_0->self)->SetUrl(::vl::Nullable<::vl::WString>(::vl::__vwsn::This(__vwsnthis_0->textUrl)->GetText())); - ::vl::__vwsn::This(__vwsnthis_0->self)->Close(); - } - - //------------------------------------------------------------------- - __vwsnf137_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__::__vwsnf137_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__(::demo::HyperlinkWindowConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } void __vwsnf137_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + { + ::vl::__vwsn::This(__vwsnthis_0->self)->SetUrl(::vl::Nullable<::vl::WString>(::vl::__vwsn::This(__vwsnthis_0->textUrl)->GetText())); + ::vl::__vwsn::This(__vwsnthis_0->self)->Close(); + } + + //------------------------------------------------------------------- + + __vwsnf138_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__::__vwsnf138_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__(::demo::HyperlinkWindowConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf138_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const { ::vl::__vwsn::This(__vwsnthis_0->self)->SetUrl(::vl::Nullable<::vl::WString>()); ::vl::__vwsn::This(__vwsnthis_0->self)->Close(); @@ -1156,12 +1174,12 @@ Closures //------------------------------------------------------------------- - __vwsnf138_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__::__vwsnf138_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__(::demo::RepeatItemTemplateConstructor* __vwsnctorthis_0) + __vwsnf139_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__::__vwsnf139_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__(::demo::RepeatItemTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf138_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf139_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_1)->GetText(); auto __vwsn_new_ = ::vl::__vwsn::Unbox<::vl::WString>(__vwsn_value_); @@ -1174,18 +1192,6 @@ Closures //------------------------------------------------------------------- - __vwsnf139_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::__vwsnf139_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf139_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const - { - ::vl::__vwsn::EventInvoke(::vl::__vwsn::This(__vwsnthis_0->self)->OnMakeFontLarger)(); - } - - //------------------------------------------------------------------- - __vwsnf13_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__::__vwsnf13_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__(::demo::DataGridTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -1205,7 +1211,19 @@ Closures { } - void __vwsnf140_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const + void __vwsnf140_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const + { + ::vl::__vwsn::EventInvoke(::vl::__vwsn::This(__vwsnthis_0->self)->OnMakeFontLarger)(); + } + + //------------------------------------------------------------------- + + __vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::__vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::operator()(const ::vl::reflection::description::Value& __vwsn_value_) const { auto __vwsn_old_ = ::vl::__vwsn::This(__vwsnthis_0->__vwsn_precompile_21)->GetEnabled(); auto __vwsn_new_ = ::vl::__vwsn::Unbox(__vwsn_value_); @@ -1218,26 +1236,14 @@ Closures //------------------------------------------------------------------- - __vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::__vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - } - - void __vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const - { - ::vl::__vwsn::EventInvoke(::vl::__vwsn::This(__vwsnthis_0->self)->OnMakeFontSmaller)(); - } - - //------------------------------------------------------------------- - __vwsnf142_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::__vwsnf142_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnf142_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::operator()() const + void __vwsnf142_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const { - ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateFont(GLOBAL_NAME ChangeFontSize(::vl::__vwsn::This(__vwsnthis_0->textBoxS)->GetFont(), static_cast<::vl::vint>(5))); + ::vl::__vwsn::EventInvoke(::vl::__vwsn::This(__vwsnthis_0->self)->OnMakeFontSmaller)(); } //------------------------------------------------------------------- @@ -1248,6 +1254,18 @@ Closures } void __vwsnf143_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::operator()() const + { + ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateFont(GLOBAL_NAME ChangeFontSize(::vl::__vwsn::This(__vwsnthis_0->textBoxS)->GetFont(), static_cast<::vl::vint>(5))); + } + + //------------------------------------------------------------------- + + __vwsnf144_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::__vwsnf144_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + } + + void __vwsnf144_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__::operator()() const { ::vl::__vwsn::This(__vwsnthis_0->self)->UpdateFont(GLOBAL_NAME ChangeFontSize(::vl::__vwsn::This(__vwsnthis_0->textBoxS)->GetFont(), (- static_cast<::vl::vint>(5)))); } @@ -4330,39 +4348,39 @@ Closures //------------------------------------------------------------------- - __vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::DateEditorConstructor* __vwsnctorthis_0) + __vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::RepeatTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::demo::DateEditor*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiScroll*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::Unbox<::vl::DateTime>(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCellValue()); } catch(...){ return ::vl::__vwsn::Parse<::vl::DateTime>(::vl::WString(L"2000-01-01 00:00:00.000", false)); } }(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetPosition(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_0 = __vwsnthis_0->hTracker); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PositionChanged, ::vl::Func(this, &__vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4372,13 +4390,13 @@ Closures return false; } - bool __vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::demo::DateEditor*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->PositionChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiScroll*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -4390,7 +4408,7 @@ Closures __vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::DateEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiDateComboBox*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::demo::DateEditor*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; @@ -4398,8 +4416,8 @@ Closures void __vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Box(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelectedDate()); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(__vwsn_bind_activator_result_); + auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::Unbox<::vl::DateTime>(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCellValue()); } catch(...){ return ::vl::__vwsn::Parse<::vl::DateTime>(::vl::WString(L"2000-01-01 00:00:00.000", false)); } }(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } void __vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) @@ -4412,8 +4430,8 @@ Closures if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->comboBox); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedDateChanged, ::vl::Func(this, &__vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; @@ -4434,8 +4452,8 @@ Closures if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedDateChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiDateComboBox*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::demo::DateEditor*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -4444,39 +4462,39 @@ Closures //------------------------------------------------------------------- - __vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::DateFilterConstructor* __vwsnctorthis_0) + __vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::DateEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiSelectableButton*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiDateComboBox*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelected(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Box(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelectedDate()); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(__vwsn_bind_activator_result_); } - void __vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->checkFrom); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, ::vl::Func(this, &__vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_0 = __vwsnthis_0->comboBox); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedDateChanged, ::vl::Func(this, &__vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4486,13 +4504,13 @@ Closures return false; } - bool __vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiSelectableButton*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedDateChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiDateComboBox*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -4526,7 +4544,7 @@ Closures if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->checkTo); + (__vwsn_bind_cache_0 = __vwsnthis_0->checkFrom); (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, ::vl::Func(this, &__vwsnc39_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } @@ -4574,17 +4592,74 @@ Closures //------------------------------------------------------------------- - __vwsnc40_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter::__vwsnc40_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter(::demo::DateFilter* __vwsnctorthis_0) + __vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::DateFilterConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiSelectableButton*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelected(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->checkTo); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, ::vl::Func(this, &__vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiSelectableButton*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc41_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter::__vwsnc41_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter(::demo::DateFilter* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { } - void __vwsnc40_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter::SetCallback(::vl::presentation::controls::list::IDataProcessorCallback* value) + void __vwsnc41_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter::SetCallback(::vl::presentation::controls::list::IDataProcessorCallback* value) { (__vwsnthis_0->callback = value); } - bool __vwsnc40_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter::Filter(const ::vl::reflection::description::Value& row) + bool __vwsnc41_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter::Filter(const ::vl::reflection::description::Value& row) { auto date = ::vl::__vwsn::This(::vl::__vwsn::Unbox<::vl::Ptr<::demo::MyDataItem>>(row).Obj())->GetBirthday(); if (::vl::__vwsn::This(__vwsnthis_0->checkFrom)->GetSelected()) @@ -4606,7 +4681,7 @@ Closures //------------------------------------------------------------------- - __vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextEditorConstructor* __vwsnctorthis_0) + __vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::demo::TextEditor*>(nullptr); @@ -4615,69 +4690,12 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::Unbox<::vl::WString>(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCellValue()); } catch(...){ return ::vl::WString(L"", false); } }(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::demo::TextEditor*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextEditorConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiSinglelineTextBox*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Box(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText()); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(__vwsn_bind_activator_result_); - } - void __vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); @@ -4688,8 +4706,8 @@ Closures if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->textBox); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; @@ -4710,8 +4728,8 @@ Closures if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiSinglelineTextBox*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::demo::TextEditor*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -4720,39 +4738,39 @@ Closures //------------------------------------------------------------------- - __vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0) + __vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::demo::CategoryDisplayer*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiSinglelineTextBox*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = GLOBAL_NAME ToColor(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCategory()); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::Box(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetText()); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(__vwsn_bind_activator_result_); } - void __vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0() + void __vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CategoryChanged, ::vl::Func(this, &__vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_0 = __vwsnthis_0->textBox); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, ::vl::Func(this, &__vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4762,13 +4780,13 @@ Closures return false; } - bool __vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CategoryChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::demo::CategoryDisplayer*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->TextChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiSinglelineTextBox*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -4788,7 +4806,7 @@ Closures void __vwsnc44_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = GLOBAL_NAME ToString(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCategory()); + auto __vwsn_bind_activator_result_ = GLOBAL_NAME ToColor(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCategory()); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -4845,11 +4863,11 @@ Closures void __vwsnc45_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); + auto __vwsn_bind_activator_result_ = GLOBAL_NAME ToString(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCategory()); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc45_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc45_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0() { this->__vwsn_bind_activator_(); } @@ -4860,7 +4878,7 @@ Closures { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc45_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CategoryChanged, ::vl::Func(this, &__vwsnc45_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; @@ -4881,7 +4899,7 @@ Closures if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CategoryChanged, __vwsn_bind_handler_0_0); (__vwsn_bind_cache_0 = static_cast<::demo::CategoryDisplayer*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; @@ -4891,39 +4909,39 @@ Closures //------------------------------------------------------------------- - __vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryEditorConstructor* __vwsnctorthis_0) + __vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::demo::CategoryEditor*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::demo::CategoryDisplayer*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->items.Obj())->IndexOf(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCellValue()); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -4933,13 +4951,13 @@ Closures return false; } - bool __vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::demo::CategoryEditor*>(nullptr)); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::demo::CategoryDisplayer*>(nullptr)); (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); return true; } @@ -4951,7 +4969,7 @@ Closures __vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiComboBoxListControl*>(nullptr); + this->__vwsn_bind_cache_0 = static_cast<::demo::CategoryEditor*>(nullptr); this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; @@ -4959,8 +4977,8 @@ Closures void __vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelectedItem(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(__vwsn_bind_activator_result_); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->items.Obj())->IndexOf(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCellValue()); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } void __vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) @@ -4973,8 +4991,8 @@ Closures if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->comboBox); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedIndexChanged, ::vl::Func(this, &__vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; @@ -4991,6 +5009,63 @@ Closures } bool __vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::demo::CategoryEditor*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryEditorConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiComboBoxListControl*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelectedItem(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(__vwsn_bind_activator_result_); + } + + void __vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->comboBox); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedIndexChanged, ::vl::Func(this, &__vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -5005,7 +5080,7 @@ Closures //------------------------------------------------------------------- - __vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryItemTemplateConstructor* __vwsnctorthis_0) + __vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryItemTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::demo::CategoryItemTemplate*>(nullptr); @@ -5014,30 +5089,30 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -5047,7 +5122,7 @@ Closures return false; } - bool __vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -5062,63 +5137,6 @@ Closures //------------------------------------------------------------------- - __vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryVisualizerConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::demo::CategoryVisualizer*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); - } - - void __vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::demo::CategoryVisualizer*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - __vwsnc4_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance___vl_presentation_controls_list_IDataSorter::__vwsnc4_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance___vl_presentation_controls_list_IDataSorter(::demo::DataGridTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { @@ -5146,7 +5164,7 @@ Closures void __vwsnc50_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { - auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::Unbox<::demo::MyCategory>(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCellValue()); } catch(...){ return ::demo::MyCategory::Black; } }(); + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } @@ -5161,7 +5179,7 @@ Closures { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc50_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc50_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; @@ -5178,6 +5196,63 @@ Closures } bool __vwsnc50_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::demo::CategoryVisualizer*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryVisualizerConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::demo::CategoryVisualizer*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::Unbox<::demo::MyCategory>(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCellValue()); } catch(...){ return ::demo::MyCategory::Black; } }(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); + } + + void __vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -5192,7 +5267,7 @@ Closures //------------------------------------------------------------------- - __vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderDisplayerConstructor* __vwsnctorthis_0) + __vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderDisplayerConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::demo::GenderDisplayer*>(nullptr); @@ -5201,30 +5276,30 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(::vl::__vwsn::Ensure(::vl::__vwsn::SharedPtrCast<::vl::presentation::GuiImageData>(::vl::__vwsn::This(__vwsnthis_0->self)->ResolveResource(::vl::WString(L"res", false), (::vl::WString(L"MiscImages/", false) + GLOBAL_NAME ToString(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetGender())), true).Obj())).Obj())->GetImage(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0() + void __vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0() { this->__vwsn_bind_activator_(); } - bool __vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->GenderChanged, ::vl::Func(this, &__vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->GenderChanged, ::vl::Func(this, &__vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -5234,7 +5309,7 @@ Closures return false; } - bool __vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -5249,7 +5324,7 @@ Closures //------------------------------------------------------------------- - __vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderEditorConstructor* __vwsnctorthis_0) + __vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderEditorConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::demo::GenderEditor*>(nullptr); @@ -5258,69 +5333,12 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(::vl::__vwsn::This(__vwsnthis_0->self)->items.Obj())->IndexOf(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCellValue()); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) - { - this->__vwsn_bind_activator_(); - } - - bool __vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() - { - if ((! __vwsn_bind_opened_)) - { - (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); - return true; - } - return false; - } - - bool __vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() - { - if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) - { - this->__vwsn_bind_activator_(); - return true; - } - return false; - } - - bool __vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() - { - if ((! __vwsn_bind_closed_)) - { - (__vwsn_bind_closed_ = true); - ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, __vwsn_bind_handler_0_0); - (__vwsn_bind_cache_0 = static_cast<::demo::GenderEditor*>(nullptr)); - (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); - return true; - } - return false; - } - - //------------------------------------------------------------------- - - __vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderEditorConstructor* __vwsnctorthis_0) - :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) - { - this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiComboBoxListControl*>(nullptr); - this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); - this->__vwsn_bind_opened_ = false; - this->__vwsn_bind_closed_ = false; - } - - void __vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() - { - auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelectedItem(); - ::vl::__vwsn::EventInvoke(this->ValueChanged)(__vwsn_bind_activator_result_); - } - void __vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); @@ -5331,8 +5349,8 @@ Closures if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); - (__vwsn_bind_cache_0 = __vwsnthis_0->comboBox); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedIndexChanged, ::vl::Func(this, &__vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_cache_0 = __vwsnthis_0->self); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; @@ -5349,6 +5367,63 @@ Closures } bool __vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + { + if ((! __vwsn_bind_closed_)) + { + (__vwsn_bind_closed_ = true); + ::vl::__vwsn::EventDetach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, __vwsn_bind_handler_0_0); + (__vwsn_bind_cache_0 = static_cast<::demo::GenderEditor*>(nullptr)); + (__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>()); + return true; + } + return false; + } + + //------------------------------------------------------------------- + + __vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderEditorConstructor* __vwsnctorthis_0) + :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) + { + this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiComboBoxListControl*>(nullptr); + this->__vwsn_bind_handler_0_0 = ::vl::Ptr<::vl::reflection::description::IEventHandler>(); + this->__vwsn_bind_opened_ = false; + this->__vwsn_bind_closed_ = false; + } + + void __vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + { + auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsn_bind_cache_0)->GetSelectedItem(); + ::vl::__vwsn::EventInvoke(this->ValueChanged)(__vwsn_bind_activator_result_); + } + + void __vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + { + this->__vwsn_bind_activator_(); + } + + bool __vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + { + if ((! __vwsn_bind_opened_)) + { + (__vwsn_bind_opened_ = true); + (__vwsn_bind_cache_0 = __vwsnthis_0->comboBox); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->SelectedIndexChanged, ::vl::Func(this, &__vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + return true; + } + return false; + } + + bool __vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + { + if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) + { + this->__vwsn_bind_activator_(); + return true; + } + return false; + } + + bool __vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -5363,7 +5438,7 @@ Closures //------------------------------------------------------------------- - __vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderVisualizerConstructor* __vwsnctorthis_0) + __vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderVisualizerConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::demo::GenderVisualizer*>(nullptr); @@ -5372,30 +5447,30 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = [&](){ try{ return ::vl::__vwsn::Unbox<::demo::MyGender>(::vl::__vwsn::This(__vwsn_bind_cache_0)->GetCellValue()); } catch(...){ return ::demo::MyGender::Male; } }(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->self); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->CellValueChanged, ::vl::Func(this, &__vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -5405,7 +5480,7 @@ Closures return false; } - bool __vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -5420,20 +5495,20 @@ Closures //------------------------------------------------------------------- - __vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::RepeatItemTemplateConstructor* __vwsnctorthis_0) + __vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::RepeatItemTemplateConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_opened_ = false; this->__vwsn_bind_closed_ = false; } - void __vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = ::vl::__vwsn::This(__vwsnthis_0->ViewModel.Obj())->GetName(); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - bool __vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { @@ -5443,7 +5518,7 @@ Closures return false; } - bool __vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -5453,7 +5528,7 @@ Closures return false; } - bool __vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -5465,7 +5540,7 @@ Closures //------------------------------------------------------------------- - __vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0) + __vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0) :__vwsnthis_0(::vl::__vwsn::This(__vwsnctorthis_0)) { this->__vwsn_bind_cache_0 = static_cast<::vl::presentation::controls::GuiSinglelineTextBox*>(nullptr); @@ -5474,30 +5549,30 @@ Closures this->__vwsn_bind_closed_ = false; } - void __vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() + void __vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_activator_() { auto __vwsn_bind_activator_result_ = (::vl::__vwsn::This(__vwsn_bind_cache_0)->GetFont().size > static_cast<::vl::vint>(5)); ::vl::__vwsn::EventInvoke(this->ValueChanged)(::vl::__vwsn::Box(__vwsn_bind_activator_result_)); } - void __vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) + void __vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1) { this->__vwsn_bind_activator_(); } - bool __vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() + bool __vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Open() { if ((! __vwsn_bind_opened_)) { (__vwsn_bind_opened_ = true); (__vwsn_bind_cache_0 = __vwsnthis_0->textBoxS); - (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); + (__vwsn_bind_handler_0_0 = ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_bind_cache_0)->FontChanged, ::vl::Func(this, &__vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::__vwsn_bind_callback_0_0))); return true; } return false; } - bool __vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() + bool __vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Update() { if ((__vwsn_bind_opened_ && (! __vwsn_bind_closed_))) { @@ -5507,7 +5582,7 @@ Closures return false; } - bool __vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() + bool __vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription::Close() { if ((! __vwsn_bind_closed_)) { @@ -7862,10 +7937,13 @@ Class (::demo::RepeatTabPageConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); } { - ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetRowsAndColumns(static_cast<::vl::vint>(1), static_cast<::vl::vint>(2)); + ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetRowsAndColumns(static_cast<::vl::vint>(3), static_cast<::vl::vint>(3)); ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetRowOption(static_cast<::vl::vint>(0), [&](){ ::vl::presentation::compositions::GuiCellOption __vwsn_temp__; __vwsn_temp__.composeType = ::vl::presentation::compositions::GuiCellOption::ComposeType::Percentage; __vwsn_temp__.percentage = static_cast(1.0); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetRowOption(static_cast<::vl::vint>(1), [&](){ ::vl::presentation::compositions::GuiCellOption __vwsn_temp__; __vwsn_temp__.composeType = ::vl::presentation::compositions::GuiCellOption::ComposeType::Absolute; __vwsn_temp__.absolute = static_cast<::vl::vint>(20); return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetRowOption(static_cast<::vl::vint>(2), [&](){ ::vl::presentation::compositions::GuiCellOption __vwsn_temp__; __vwsn_temp__.composeType = ::vl::presentation::compositions::GuiCellOption::ComposeType::Absolute; __vwsn_temp__.absolute = static_cast<::vl::vint>(20); return __vwsn_temp__; }()); ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetColumnOption(static_cast<::vl::vint>(0), [&](){ ::vl::presentation::compositions::GuiCellOption __vwsn_temp__; __vwsn_temp__.composeType = ::vl::presentation::compositions::GuiCellOption::ComposeType::Percentage; __vwsn_temp__.percentage = static_cast(0.5); return __vwsn_temp__; }()); ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetColumnOption(static_cast<::vl::vint>(1), [&](){ ::vl::presentation::compositions::GuiCellOption __vwsn_temp__; __vwsn_temp__.composeType = ::vl::presentation::compositions::GuiCellOption::ComposeType::MinSize; return __vwsn_temp__; }()); + ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetColumnOption(static_cast<::vl::vint>(2), [&](){ ::vl::presentation::compositions::GuiCellOption __vwsn_temp__; __vwsn_temp__.composeType = ::vl::presentation::compositions::GuiCellOption::ComposeType::Absolute; __vwsn_temp__.absolute = static_cast<::vl::vint>(20); return __vwsn_temp__; }()); } (this->__vwsn_precompile_1 = new ::vl::presentation::compositions::GuiCellComposition()); { @@ -8089,6 +8167,69 @@ Class (::demo::RepeatTabPageConstructor) { ::vl::__vwsn::This(this->__vwsn_precompile_0)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_10)); } + (this->__vwsn_precompile_24 = new ::vl::presentation::compositions::GuiCellComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_24)->SetSite(static_cast<::vl::vint>(1), static_cast<::vl::vint>(0), static_cast<::vl::vint>(1), static_cast<::vl::vint>(2)); + } + { + (this->hTracker = new ::vl::presentation::controls::GuiScroll(::vl::presentation::theme::ThemeName::HTracker)); + ::vl::__vwsn::This(this->hTracker)->SetPageSize(static_cast<::vl::vint>(0)); + } + { + ::vl::__vwsn::This(this->hTracker)->SetTotalSize(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"10", false))); + } + (this->__vwsn_precompile_25 = ::vl::__vwsn::This(this->hTracker)->GetBoundsComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_25)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_24)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->hTracker)->GetBoundsComposition())); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_0)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_24)); + } + (this->__vwsn_precompile_26 = new ::vl::presentation::compositions::GuiCellComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_26)->SetSite(static_cast<::vl::vint>(2), static_cast<::vl::vint>(0), static_cast<::vl::vint>(1), static_cast<::vl::vint>(2)); + } + { + (this->__vwsn_precompile_27 = new ::vl::presentation::controls::GuiScroll(::vl::presentation::theme::ThemeName::ProgressBar)); + ::vl::__vwsn::This(this->__vwsn_precompile_27)->SetPageSize(static_cast<::vl::vint>(0)); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_27)->SetTotalSize(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"10", false))); + } + (this->__vwsn_precompile_28 = ::vl::__vwsn::This(this->__vwsn_precompile_27)->GetBoundsComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_28)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_26)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_27)->GetBoundsComposition())); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_0)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_26)); + } + (this->__vwsn_precompile_29 = new ::vl::presentation::compositions::GuiCellComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_29)->SetSite(static_cast<::vl::vint>(0), static_cast<::vl::vint>(2), static_cast<::vl::vint>(1), static_cast<::vl::vint>(1)); + } + { + (this->__vwsn_precompile_30 = new ::vl::presentation::controls::GuiScroll(::vl::presentation::theme::ThemeName::VTracker)); + ::vl::__vwsn::This(this->__vwsn_precompile_30)->SetPageSize(static_cast<::vl::vint>(0)); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_30)->SetTotalSize(::vl::__vwsn::Parse<::vl::vint>(::vl::WString(L"5", false))); + } + (this->__vwsn_precompile_31 = ::vl::__vwsn::This(this->__vwsn_precompile_30)->GetBoundsComposition()); + { + ::vl::__vwsn::This(this->__vwsn_precompile_31)->SetAlignmentToParent([&](){ ::vl::presentation::Margin __vwsn_temp__; __vwsn_temp__.left = static_cast<::vl::vint>(0); __vwsn_temp__.top = static_cast<::vl::vint>(0); __vwsn_temp__.right = static_cast<::vl::vint>(0); __vwsn_temp__.bottom = static_cast<::vl::vint>(0); return __vwsn_temp__; }()); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_29)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_30)->GetBoundsComposition())); + } + { + ::vl::__vwsn::This(this->__vwsn_precompile_0)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_29)); + } { ::vl::__vwsn::This(::vl::__vwsn::This(this->self)->GetContainerComposition())->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } @@ -8114,6 +8255,11 @@ Class (::demo::RepeatTabPageConstructor) auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf99_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_22)->Clicked, __vwsn_event_handler_); } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf100_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } } RepeatTabPageConstructor::RepeatTabPageConstructor() @@ -8514,10 +8660,10 @@ Class (::demo::TextListTabPageConstructor) (this->bindableTextList = new ::vl::presentation::controls::GuiBindableTextList(::vl::presentation::theme::ThemeName::TextList)); } { - ::vl::__vwsn::This(this->bindableTextList)->SetCheckedProperty(LAMBDA(::vl_workflow_global::__vwsnf100_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->bindableTextList)->SetCheckedProperty(LAMBDA(::vl_workflow_global::__vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->bindableTextList)->SetTextProperty(LAMBDA(::vl_workflow_global::__vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->bindableTextList)->SetTextProperty(LAMBDA(::vl_workflow_global::__vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->bindableTextList)->SetVerticalAlwaysVisible(::vl::__vwsn::Parse(::vl::WString(L"false", false))); @@ -8542,23 +8688,23 @@ Class (::demo::TextListTabPageConstructor) ::vl::__vwsn::This(::vl::__vwsn::This(this->self)->GetContainerComposition())->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->comboView)->SelectedIndexChanged, __vwsn_event_handler_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf104_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_12)->Clicked, __vwsn_event_handler_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf104_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf105_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_15)->Clicked, __vwsn_event_handler_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf105_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf106_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_18)->Clicked, __vwsn_event_handler_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf106_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf107_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_21)->Clicked, __vwsn_event_handler_); } { @@ -8825,13 +8971,13 @@ Class (::demo::TreeViewTabPageConstructor) (this->bindableTreeView = new ::vl::presentation::controls::GuiBindableTreeView(::vl::presentation::theme::ThemeName::TreeView)); } { - ::vl::__vwsn::This(this->bindableTreeView)->SetChildrenProperty(LAMBDA(::vl_workflow_global::__vwsnf107_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->bindableTreeView)->SetChildrenProperty(LAMBDA(::vl_workflow_global::__vwsnf108_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->bindableTreeView)->SetImageProperty(LAMBDA(::vl_workflow_global::__vwsnf108_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->bindableTreeView)->SetImageProperty(LAMBDA(::vl_workflow_global::__vwsnf109_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(this))); } { - ::vl::__vwsn::This(this->bindableTreeView)->SetTextProperty(LAMBDA(::vl_workflow_global::__vwsnf109_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->bindableTreeView)->SetTextProperty(LAMBDA(::vl_workflow_global::__vwsnf110_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->bindableTreeView)->SetVerticalAlwaysVisible(::vl::__vwsn::Parse(::vl::WString(L"false", false))); @@ -8903,13 +9049,13 @@ Class (::demo::DateEditorConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->comboBox)->GetBoundsComposition())); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf110_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf112_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { @@ -9038,29 +9184,29 @@ Class (::demo::DateFilterConstructor) ::vl::__vwsn::This(::vl::__vwsn::This(this->self)->GetContainerComposition())->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf112_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf113_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->checkFrom)->SelectedChanged, __vwsn_event_handler_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf113_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc39_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf114_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } - { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf114_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->dateFrom)->SelectedDateChanged, __vwsn_event_handler_); - } { auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf115_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->dateFrom)->SelectedDateChanged, __vwsn_event_handler_); + } + { + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf116_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->checkTo)->SelectedChanged, __vwsn_event_handler_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc39_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf116_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf118_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->dateTo)->SelectedDateChanged, __vwsn_event_handler_); } } @@ -9102,7 +9248,7 @@ Class (::demo::DateFilter) void DateFilter::__vwsn_instance_ctor_() { - this->SetFilter(::vl::Ptr<::vl::presentation::controls::list::IDataFilter>(new ::vl_workflow_global::__vwsnc40_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter(this))); + this->SetFilter(::vl::Ptr<::vl::presentation::controls::list::IDataFilter>(new ::vl_workflow_global::__vwsnc41_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter(this))); } DateFilter::~DateFilter() @@ -9128,13 +9274,13 @@ Class (::demo::TextEditorConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->textBox)->GetBoundsComposition())); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf118_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf119_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf119_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf120_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { @@ -9238,11 +9384,6 @@ Class (::demo::CategoryDisplayerConstructor) { ::vl::__vwsn::This(::vl::__vwsn::This(this->self)->GetContainerComposition())->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } - { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf120_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(this))); - ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); - } { auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc44_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf121_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(this))); @@ -9253,6 +9394,11 @@ Class (::demo::CategoryDisplayerConstructor) ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf122_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } + { + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf123_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); + } } CategoryDisplayerConstructor::CategoryDisplayerConstructor() @@ -9301,7 +9447,7 @@ Class (::demo::CategoryEditorConstructor) (this->__vwsn_precompile_0 = new ::vl::presentation::controls::GuiBindableTextList(::vl::presentation::theme::ThemeName::TextList)); } { - ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetItemTemplate(LAMBDA(::vl_workflow_global::__vwsnf123_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetItemTemplate(LAMBDA(::vl_workflow_global::__vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetVerticalAlwaysVisible(::vl::__vwsn::Parse(::vl::WString(L"false", false))); @@ -9313,7 +9459,7 @@ Class (::demo::CategoryEditorConstructor) (this->comboBox = new ::vl::presentation::controls::GuiComboBoxListControl(::vl::presentation::theme::ThemeName::ComboBox, this->__vwsn_precompile_0)); } { - ::vl::__vwsn::This(this->comboBox)->SetItemTemplate(LAMBDA(::vl_workflow_global::__vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->comboBox)->SetItemTemplate(LAMBDA(::vl_workflow_global::__vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(this))); } (this->__vwsn_precompile_1 = ::vl::__vwsn::This(this->comboBox)->GetBoundsComposition()); { @@ -9326,13 +9472,13 @@ Class (::demo::CategoryEditorConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetItemSource(::vl::Ptr<::vl::reflection::description::IValueEnumerable>(::vl::__vwsn::This(this->self)->items)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf127_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -9378,8 +9524,8 @@ Class (::demo::CategoryItemTemplateConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_0)->GetBoundsComposition())); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf127_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf128_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { @@ -9430,13 +9576,13 @@ Class (::demo::CategoryVisualizerConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_0)->GetBoundsComposition())); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf128_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc50_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf129_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc50_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf129_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf130_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -9490,8 +9636,8 @@ Class (::demo::GenderDisplayerConstructor) ::vl::__vwsn::This(::vl::__vwsn::This(this->self)->GetContainerComposition())->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf130_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf131_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -9542,7 +9688,7 @@ Class (::demo::GenderEditorConstructor) (this->__vwsn_precompile_0 = new ::vl::presentation::controls::GuiBindableTextList(::vl::presentation::theme::ThemeName::TextList)); } { - ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetItemTemplate(LAMBDA(::vl_workflow_global::__vwsnf131_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetItemTemplate(LAMBDA(::vl_workflow_global::__vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(this))); } { ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetVerticalAlwaysVisible(::vl::__vwsn::Parse(::vl::WString(L"false", false))); @@ -9554,7 +9700,7 @@ Class (::demo::GenderEditorConstructor) (this->comboBox = new ::vl::presentation::controls::GuiComboBoxListControl(::vl::presentation::theme::ThemeName::ComboBox, this->__vwsn_precompile_0)); } { - ::vl::__vwsn::This(this->comboBox)->SetItemTemplate(LAMBDA(::vl_workflow_global::__vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(this))); + ::vl::__vwsn::This(this->comboBox)->SetItemTemplate(LAMBDA(::vl_workflow_global::__vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(this))); } (this->__vwsn_precompile_1 = ::vl::__vwsn::This(this->comboBox)->GetBoundsComposition()); { @@ -9567,13 +9713,13 @@ Class (::demo::GenderEditorConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_0)->SetItemSource(::vl::Ptr<::vl::reflection::description::IValueEnumerable>(::vl::__vwsn::This(this->self)->items)); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf135_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -9666,8 +9812,8 @@ Class (::demo::GenderVisualizerConstructor) ::vl::__vwsn::This(this->self)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_0)->GetBoundsComposition())); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf135_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf136_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -9820,11 +9966,11 @@ Class (::demo::HyperlinkWindowConstructor) ::vl::__vwsn::This(::vl::__vwsn::This(this->self)->GetContainerComposition())->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(this->__vwsn_precompile_0)); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf136_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf137_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_6)->Clicked, __vwsn_event_handler_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf137_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf138_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_9)->Clicked, __vwsn_event_handler_); } } @@ -9886,8 +10032,8 @@ Class (::demo::RepeatItemTemplateConstructor) ::vl::__vwsn::This(this->__vwsn_precompile_0)->AddChild(static_cast<::vl::presentation::compositions::GuiGraphicsComposition*>(::vl::__vwsn::This(this->__vwsn_precompile_1)->GetBoundsComposition())); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf138_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf139_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } } @@ -10193,24 +10339,24 @@ Class (::demo::TextBoxTabPageConstructor) ::vl::__vwsn::This(this->documentLabel)->SetDocument(::vl::__vwsn::Ensure(::vl::__vwsn::SharedPtrCast<::vl::presentation::DocumentModel>(::vl::__vwsn::This(__vwsn_this_)->ResolveResource(::vl::WString(L"res", false), ::vl::WString(L"TextBoxComponents/DocRelative", false), true).Obj()))); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf139_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf140_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_19)->Clicked, __vwsn_event_handler_); } { - auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); - ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf140_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(this))); + auto __vwsn_created_subscription_ = ::vl::Ptr<::vl::reflection::description::IValueSubscription>(new ::vl_workflow_global::__vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(this)); + ::vl::__vwsn::EventAttach(::vl::__vwsn::This(__vwsn_created_subscription_.Obj())->ValueChanged, LAMBDA(::vl_workflow_global::__vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(this))); ::vl::__vwsn::This(__vwsn_this_)->AddSubscription(__vwsn_created_subscription_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf142_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->__vwsn_precompile_21)->Clicked, __vwsn_event_handler_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf142_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf143_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->self)->OnMakeFontLarger, __vwsn_event_handler_); } { - auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf143_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(this)); + auto __vwsn_event_handler_ = LAMBDA(::vl_workflow_global::__vwsnf144_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(this)); ::vl::__vwsn::EventAttach(::vl::__vwsn::This(this->self)->OnMakeFontSmaller, __vwsn_event_handler_); } } diff --git a/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoPartialClasses.h b/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoPartialClasses.h index 1cbd515c..323aeaab 100644 --- a/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoPartialClasses.h +++ b/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoPartialClasses.h @@ -25,54 +25,55 @@ https://github.com/vczh-libraries namespace vl_workflow_global { - struct __vwsnf100_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; + struct __vwsnf100_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf104_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf105_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf106_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; - struct __vwsnf107_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; + struct __vwsnf107_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf108_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf109_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf10_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__; - struct __vwsnf110_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__; + struct __vwsnf110_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__; - struct __vwsnf112_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; + struct __vwsnf112_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__; struct __vwsnf113_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; struct __vwsnf114_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; struct __vwsnf115_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; struct __vwsnf116_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; struct __vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; - struct __vwsnf118_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__; + struct __vwsnf118_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; struct __vwsnf119_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__; struct __vwsnf11_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__; - struct __vwsnf120_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; + struct __vwsnf120_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__; struct __vwsnf121_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; struct __vwsnf122_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; - struct __vwsnf123_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; + struct __vwsnf123_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; struct __vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; struct __vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; struct __vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; - struct __vwsnf127_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf128_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__; + struct __vwsnf127_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; + struct __vwsnf128_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf129_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__; struct __vwsnf12_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__; - struct __vwsnf130_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__; - struct __vwsnf131_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; + struct __vwsnf130_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__; + struct __vwsnf131_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__; struct __vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; struct __vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; struct __vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; - struct __vwsnf135_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__; - struct __vwsnf136_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__; + struct __vwsnf135_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; + struct __vwsnf136_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__; struct __vwsnf137_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__; - struct __vwsnf138_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__; - struct __vwsnf139_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; + struct __vwsnf138_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__; + struct __vwsnf139_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__; struct __vwsnf13_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf140_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf142_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf143_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; + struct __vwsnf144_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf14_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf16_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__; struct __vwsnf17_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__; @@ -196,29 +197,30 @@ namespace vl_workflow_global class __vwsnc33_Demo_demo_DocumentTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc34_Demo_demo_DocumentTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc35_Demo_demo_DocumentTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc39_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc3_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance___vl_presentation_controls_list_IDataSorter; - class __vwsnc40_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter; - class __vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc41_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter; class __vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc44_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc45_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc4_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance___vl_presentation_controls_list_IDataSorter; class __vwsnc50_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - class __vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + class __vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc5_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance___vl_presentation_controls_list_IDataSorter; class __vwsnc6_Demo_demo_DocumentTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; class __vwsnc7_Demo_demo_DocumentTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; @@ -806,6 +808,8 @@ namespace demo class RepeatTabPageConstructor : public ::vl::Object, public ::vl::reflection::Description { + friend class ::vl_workflow_global::__vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf100_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf94_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf95_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf96_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__; @@ -819,6 +823,7 @@ namespace demo ::demo::RepeatTabPage* self = static_cast<::demo::RepeatTabPage*>(nullptr); ::vl::presentation::compositions::GuiRepeatStackComposition* repeatStack = static_cast<::vl::presentation::compositions::GuiRepeatStackComposition*>(nullptr); ::vl::presentation::compositions::GuiRepeatFlowComposition* repeatFlow = static_cast<::vl::presentation::compositions::GuiRepeatFlowComposition*>(nullptr); + ::vl::presentation::controls::GuiScroll* hTracker = static_cast<::vl::presentation::controls::GuiScroll*>(nullptr); ::vl::presentation::compositions::GuiTableComposition* __vwsn_precompile_0 = static_cast<::vl::presentation::compositions::GuiTableComposition*>(nullptr); ::vl::presentation::compositions::GuiCellComposition* __vwsn_precompile_1 = static_cast<::vl::presentation::compositions::GuiCellComposition*>(nullptr); ::vl::presentation::controls::GuiTab* __vwsn_precompile_2 = static_cast<::vl::presentation::controls::GuiTab*>(nullptr); @@ -843,6 +848,14 @@ namespace demo ::vl::presentation::compositions::GuiStackItemComposition* __vwsn_precompile_21 = static_cast<::vl::presentation::compositions::GuiStackItemComposition*>(nullptr); ::vl::presentation::controls::GuiButton* __vwsn_precompile_22 = static_cast<::vl::presentation::controls::GuiButton*>(nullptr); ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_23 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::presentation::compositions::GuiCellComposition* __vwsn_precompile_24 = static_cast<::vl::presentation::compositions::GuiCellComposition*>(nullptr); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_25 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::presentation::compositions::GuiCellComposition* __vwsn_precompile_26 = static_cast<::vl::presentation::compositions::GuiCellComposition*>(nullptr); + ::vl::presentation::controls::GuiScroll* __vwsn_precompile_27 = static_cast<::vl::presentation::controls::GuiScroll*>(nullptr); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_28 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); + ::vl::presentation::compositions::GuiCellComposition* __vwsn_precompile_29 = static_cast<::vl::presentation::compositions::GuiCellComposition*>(nullptr); + ::vl::presentation::controls::GuiScroll* __vwsn_precompile_30 = static_cast<::vl::presentation::controls::GuiScroll*>(nullptr); + ::vl::presentation::compositions::GuiBoundsComposition* __vwsn_precompile_31 = static_cast<::vl::presentation::compositions::GuiBoundsComposition*>(nullptr); void __vwsn_initialize_instance_(::demo::RepeatTabPage* __vwsn_this_); public: RepeatTabPageConstructor(); @@ -851,6 +864,8 @@ namespace demo class RepeatTabPage : public ::vl::presentation::controls::GuiTabPage, public ::demo::RepeatTabPageConstructor, public ::vl::reflection::Description { friend class ::demo::RepeatTabPageConstructor; + friend class ::vl_workflow_global::__vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf100_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf94_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf95_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf96_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__; @@ -874,13 +889,13 @@ namespace demo class TextListTabPageConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend struct ::vl_workflow_global::__vwsnf100_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf104_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf105_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf106_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf107_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -922,13 +937,13 @@ namespace demo class TextListTabPage : public ::vl::presentation::controls::GuiTabPage, public ::demo::TextListTabPageConstructor, public ::vl::reflection::Description { friend class ::demo::TextListTabPageConstructor; - friend struct ::vl_workflow_global::__vwsnf100_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf104_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf105_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf106_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf107_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -941,9 +956,9 @@ namespace demo class TreeViewTabPageConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend struct ::vl_workflow_global::__vwsnf107_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf108_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf109_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf110_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1009,9 +1024,9 @@ namespace demo class TreeViewTabPage : public ::vl::presentation::controls::GuiTabPage, public ::demo::TreeViewTabPageConstructor, public ::vl::reflection::Description { friend class ::demo::TreeViewTabPageConstructor; - friend struct ::vl_workflow_global::__vwsnf107_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf108_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf109_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf110_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1024,10 +1039,10 @@ namespace demo class DateEditorConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf110_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf112_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1043,10 +1058,10 @@ namespace demo class DateEditor : public ::vl::presentation::templates::GuiGridEditorTemplate, public ::demo::DateEditorConstructor, public ::vl::reflection::Description { friend class ::demo::DateEditorConstructor; - friend class ::vl_workflow_global::__vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf110_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf112_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1057,14 +1072,14 @@ namespace demo class DateFilterConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc39_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf112_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf113_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf114_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf115_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf116_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf118_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1088,16 +1103,16 @@ namespace demo class DateFilter : public ::vl::presentation::controls::GuiCustomControl, public ::demo::DateFilterConstructor, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc40_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter; + friend class ::vl_workflow_global::__vwsnc41_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter; friend class ::demo::DateFilterConstructor; - friend class ::vl_workflow_global::__vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc39_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf112_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf113_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf114_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf115_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf116_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf118_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1115,10 +1130,10 @@ namespace demo class TextEditorConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf118_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf119_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf120_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1134,10 +1149,10 @@ namespace demo class TextEditor : public ::vl::presentation::templates::GuiGridEditorTemplate, public ::demo::TextEditorConstructor, public ::vl::reflection::Description { friend class ::demo::TextEditorConstructor; - friend class ::vl_workflow_global::__vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf118_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf119_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf120_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1148,12 +1163,12 @@ namespace demo class CategoryDisplayerConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc44_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc45_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf120_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf121_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf122_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf123_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1174,12 +1189,12 @@ namespace demo class CategoryDisplayer : public ::vl::presentation::controls::GuiCustomControl, public ::demo::CategoryDisplayerConstructor, public ::vl::reflection::Description { friend class ::demo::CategoryDisplayerConstructor; - friend class ::vl_workflow_global::__vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc44_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc45_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf120_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf121_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf122_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf123_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1194,12 +1209,12 @@ namespace demo class CategoryEditorConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf123_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf127_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1216,12 +1231,12 @@ namespace demo class CategoryEditor : public ::vl::presentation::templates::GuiGridEditorTemplate, public ::demo::CategoryEditorConstructor, public ::vl::reflection::Description { friend class ::demo::CategoryEditorConstructor; - friend class ::vl_workflow_global::__vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf123_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf127_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1233,8 +1248,8 @@ namespace demo class CategoryItemTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf127_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf128_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1251,8 +1266,8 @@ namespace demo class CategoryItemTemplate : public ::vl::presentation::templates::GuiTextListItemTemplate, public ::demo::CategoryItemTemplateConstructor, public ::vl::reflection::Description { friend class ::demo::CategoryItemTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf127_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf128_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1265,10 +1280,10 @@ namespace demo class CategoryVisualizerConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc50_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf128_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf129_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf130_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1284,10 +1299,10 @@ namespace demo class CategoryVisualizer : public ::vl::presentation::templates::GuiGridVisualizerTemplate, public ::demo::CategoryVisualizerConstructor, public ::vl::reflection::Description { friend class ::demo::CategoryVisualizerConstructor; - friend class ::vl_workflow_global::__vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc50_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf128_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf129_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf130_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1298,8 +1313,8 @@ namespace demo class GenderDisplayerConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf130_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf131_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1315,8 +1330,8 @@ namespace demo class GenderDisplayer : public ::vl::presentation::controls::GuiCustomControl, public ::demo::GenderDisplayerConstructor, public ::vl::reflection::Description { friend class ::demo::GenderDisplayerConstructor; - friend class ::vl_workflow_global::__vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf130_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf131_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1331,12 +1346,12 @@ namespace demo class GenderEditorConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf131_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf135_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1353,12 +1368,12 @@ namespace demo class GenderEditor : public ::vl::presentation::templates::GuiGridEditorTemplate, public ::demo::GenderEditorConstructor, public ::vl::reflection::Description { friend class ::demo::GenderEditorConstructor; - friend class ::vl_workflow_global::__vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend class ::vl_workflow_global::__vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf131_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf135_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1398,8 +1413,8 @@ namespace demo class GenderVisualizerConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf135_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf136_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1415,8 +1430,8 @@ namespace demo class GenderVisualizer : public ::vl::presentation::templates::GuiGridVisualizerTemplate, public ::demo::GenderVisualizerConstructor, public ::vl::reflection::Description { friend class ::demo::GenderVisualizerConstructor; - friend class ::vl_workflow_global::__vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf135_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf136_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1427,8 +1442,8 @@ namespace demo class HyperlinkWindowConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend struct ::vl_workflow_global::__vwsnf136_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf137_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf138_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1455,8 +1470,8 @@ namespace demo class HyperlinkWindow : public ::vl::presentation::controls::GuiWindow, public ::demo::HyperlinkWindowConstructor, public ::vl::reflection::Description { friend class ::demo::HyperlinkWindowConstructor; - friend struct ::vl_workflow_global::__vwsnf136_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf137_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf138_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1471,8 +1486,8 @@ namespace demo class RepeatItemTemplateConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf138_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf139_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1489,8 +1504,8 @@ namespace demo class RepeatItemTemplate : public ::vl::presentation::templates::GuiControlTemplate, public ::demo::RepeatItemTemplateConstructor, public ::vl::reflection::Description { friend class ::demo::RepeatItemTemplateConstructor; - friend class ::vl_workflow_global::__vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf138_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; + friend struct ::vl_workflow_global::__vwsnf139_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1503,12 +1518,12 @@ namespace demo class TextBoxTabPageConstructor : public ::vl::Object, public ::vl::reflection::Description { - friend class ::vl_workflow_global::__vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf139_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf140_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf142_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf143_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf144_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1549,12 +1564,12 @@ namespace demo class TextBoxTabPage : public ::vl::presentation::controls::GuiTabPage, public ::demo::TextBoxTabPageConstructor, public ::vl::reflection::Description { friend class ::demo::TextBoxTabPageConstructor; - friend class ::vl_workflow_global::__vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; - friend struct ::vl_workflow_global::__vwsnf139_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; + friend class ::vl_workflow_global::__vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription; friend struct ::vl_workflow_global::__vwsnf140_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf142_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; friend struct ::vl_workflow_global::__vwsnf143_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; + friend struct ::vl_workflow_global::__vwsnf144_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__; #ifndef VCZH_DEBUG_NO_REFLECTION friend struct ::vl::reflection::description::CustomTypeDescriptorSelector; #endif @@ -1641,13 +1656,13 @@ namespace vl_workflow_global Closures ***********************************************************************/ - struct __vwsnf100_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__ + struct __vwsnf100_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__ { - ::demo::TextListTabPageConstructor* __vwsnthis_0; + ::demo::RepeatTabPageConstructor* __vwsnthis_0; - __vwsnf100_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0); + __vwsnf100_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance__(::demo::RepeatTabPageConstructor* __vwsnctorthis_0); - bool operator()(const ::vl::reflection::description::Value& __vwsn_item_, bool __vwsn_value_, bool __vwsn_update_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__ @@ -1656,7 +1671,7 @@ Closures __vwsnf101_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0); - ::vl::WString operator()(const ::vl::reflection::description::Value& __vwsn_item_) const; + bool operator()(const ::vl::reflection::description::Value& __vwsn_item_, bool __vwsn_value_, bool __vwsn_update_) const; }; struct __vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__ @@ -1665,7 +1680,7 @@ Closures __vwsnf102_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + ::vl::WString operator()(const ::vl::reflection::description::Value& __vwsn_item_) const; }; struct __vwsnf103_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__ @@ -1704,13 +1719,13 @@ Closures void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; }; - struct __vwsnf107_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__ + struct __vwsnf107_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__ { - ::demo::TreeViewTabPageConstructor* __vwsnthis_0; + ::demo::TextListTabPageConstructor* __vwsnthis_0; - __vwsnf107_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(::demo::TreeViewTabPageConstructor* __vwsnctorthis_0); + __vwsnf107_Demo_demo_TextListTabPageConstructor___vwsn_initialize_instance__(::demo::TextListTabPageConstructor* __vwsnctorthis_0); - ::vl::Ptr<::vl::reflection::description::IValueEnumerable> operator()(const ::vl::reflection::description::Value& __vwsn_item_) const; + void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; }; struct __vwsnf108_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__ @@ -1719,7 +1734,7 @@ Closures __vwsnf108_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(::demo::TreeViewTabPageConstructor* __vwsnctorthis_0); - ::vl::Ptr<::vl::presentation::GuiImageData> operator()(const ::vl::reflection::description::Value& __vwsn_item_) const; + ::vl::Ptr<::vl::reflection::description::IValueEnumerable> operator()(const ::vl::reflection::description::Value& __vwsn_item_) const; }; struct __vwsnf109_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__ @@ -1728,7 +1743,7 @@ Closures __vwsnf109_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(::demo::TreeViewTabPageConstructor* __vwsnctorthis_0); - ::vl::WString operator()(const ::vl::reflection::description::Value& __vwsn_item_) const; + ::vl::Ptr<::vl::presentation::GuiImageData> operator()(const ::vl::reflection::description::Value& __vwsn_item_) const; }; struct __vwsnf10_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__ @@ -1740,13 +1755,13 @@ Closures ::vl::presentation::templates::GuiGridEditorTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; - struct __vwsnf110_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__ + struct __vwsnf110_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__ { - ::demo::DateEditorConstructor* __vwsnthis_0; + ::demo::TreeViewTabPageConstructor* __vwsnthis_0; - __vwsnf110_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__(::demo::DateEditorConstructor* __vwsnctorthis_0); + __vwsnf110_Demo_demo_TreeViewTabPageConstructor___vwsn_initialize_instance__(::demo::TreeViewTabPageConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::WString operator()(const ::vl::reflection::description::Value& __vwsn_item_) const; }; struct __vwsnf111_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__ @@ -1758,13 +1773,13 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf112_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__ + struct __vwsnf112_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__ { - ::demo::DateFilterConstructor* __vwsnthis_0; + ::demo::DateEditorConstructor* __vwsnthis_0; - __vwsnf112_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(::demo::DateFilterConstructor* __vwsnctorthis_0); + __vwsnf112_Demo_demo_DateEditorConstructor___vwsn_initialize_instance__(::demo::DateEditorConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf113_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__ @@ -1773,7 +1788,7 @@ Closures __vwsnf113_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(::demo::DateFilterConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; }; struct __vwsnf114_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__ @@ -1782,7 +1797,7 @@ Closures __vwsnf114_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(::demo::DateFilterConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf115_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__ @@ -1800,7 +1815,7 @@ Closures __vwsnf116_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(::demo::DateFilterConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; }; struct __vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__ @@ -1809,16 +1824,16 @@ Closures __vwsnf117_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(::demo::DateFilterConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf118_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__ + struct __vwsnf118_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__ { - ::demo::TextEditorConstructor* __vwsnthis_0; + ::demo::DateFilterConstructor* __vwsnthis_0; - __vwsnf118_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__(::demo::TextEditorConstructor* __vwsnctorthis_0); + __vwsnf118_Demo_demo_DateFilterConstructor___vwsn_initialize_instance__(::demo::DateFilterConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; }; struct __vwsnf119_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__ @@ -1839,11 +1854,11 @@ Closures ::vl::reflection::description::Value operator()(const ::vl::reflection::description::Value& __vwsn_item_, const ::vl::reflection::description::Value& __vwsn_value_, bool __vwsn_update_) const; }; - struct __vwsnf120_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__ + struct __vwsnf120_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__ { - ::demo::CategoryDisplayerConstructor* __vwsnthis_0; + ::demo::TextEditorConstructor* __vwsnthis_0; - __vwsnf120_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0); + __vwsnf120_Demo_demo_TextEditorConstructor___vwsn_initialize_instance__(::demo::TextEditorConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; @@ -1866,13 +1881,13 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf123_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__ + struct __vwsnf123_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__ { - ::demo::CategoryEditorConstructor* __vwsnthis_0; + ::demo::CategoryDisplayerConstructor* __vwsnthis_0; - __vwsnf123_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0); + __vwsnf123_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance__(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiListItemTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__ @@ -1881,7 +1896,7 @@ Closures __vwsnf124_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + ::vl::presentation::templates::GuiListItemTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__ @@ -1890,7 +1905,7 @@ Closures __vwsnf125_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf126_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__ @@ -1902,20 +1917,20 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf127_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf127_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__ { - ::demo::CategoryItemTemplateConstructor* __vwsnthis_0; + ::demo::CategoryEditorConstructor* __vwsnthis_0; - __vwsnf127_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__(::demo::CategoryItemTemplateConstructor* __vwsnctorthis_0); + __vwsnf127_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance__(::demo::CategoryEditorConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf128_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__ + struct __vwsnf128_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__ { - ::demo::CategoryVisualizerConstructor* __vwsnthis_0; + ::demo::CategoryItemTemplateConstructor* __vwsnthis_0; - __vwsnf128_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__(::demo::CategoryVisualizerConstructor* __vwsnctorthis_0); + __vwsnf128_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance__(::demo::CategoryItemTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; @@ -1938,22 +1953,22 @@ Closures ::vl::WString operator()(const ::vl::reflection::description::Value& __vwsn_item_) const; }; - struct __vwsnf130_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__ + struct __vwsnf130_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__ { - ::demo::GenderDisplayerConstructor* __vwsnthis_0; + ::demo::CategoryVisualizerConstructor* __vwsnthis_0; - __vwsnf130_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__(::demo::GenderDisplayerConstructor* __vwsnctorthis_0); + __vwsnf130_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance__(::demo::CategoryVisualizerConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf131_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__ + struct __vwsnf131_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__ { - ::demo::GenderEditorConstructor* __vwsnthis_0; + ::demo::GenderDisplayerConstructor* __vwsnthis_0; - __vwsnf131_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0); + __vwsnf131_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance__(::demo::GenderDisplayerConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiListItemTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__ @@ -1962,7 +1977,7 @@ Closures __vwsnf132_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0); - ::vl::presentation::templates::GuiTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; + ::vl::presentation::templates::GuiListItemTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__ @@ -1971,7 +1986,7 @@ Closures __vwsnf133_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + ::vl::presentation::templates::GuiTemplate* operator()(const ::vl::reflection::description::Value& __vwsn_viewModel_) const; }; struct __vwsnf134_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__ @@ -1983,22 +1998,22 @@ Closures void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf135_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__ + struct __vwsnf135_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__ { - ::demo::GenderVisualizerConstructor* __vwsnthis_0; + ::demo::GenderEditorConstructor* __vwsnthis_0; - __vwsnf135_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__(::demo::GenderVisualizerConstructor* __vwsnctorthis_0); + __vwsnf135_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance__(::demo::GenderEditorConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf136_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__ + struct __vwsnf136_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__ { - ::demo::HyperlinkWindowConstructor* __vwsnthis_0; + ::demo::GenderVisualizerConstructor* __vwsnthis_0; - __vwsnf136_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__(::demo::HyperlinkWindowConstructor* __vwsnctorthis_0); + __vwsnf136_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance__(::demo::GenderVisualizerConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf137_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__ @@ -2010,24 +2025,24 @@ Closures void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; }; - struct __vwsnf138_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__ + struct __vwsnf138_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__ + { + ::demo::HyperlinkWindowConstructor* __vwsnthis_0; + + __vwsnf138_Demo_demo_HyperlinkWindowConstructor___vwsn_initialize_instance__(::demo::HyperlinkWindowConstructor* __vwsnctorthis_0); + + void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + }; + + struct __vwsnf139_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__ { ::demo::RepeatItemTemplateConstructor* __vwsnthis_0; - __vwsnf138_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__(::demo::RepeatItemTemplateConstructor* __vwsnctorthis_0); + __vwsnf139_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance__(::demo::RepeatItemTemplateConstructor* __vwsnctorthis_0); void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; - struct __vwsnf139_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__ - { - ::demo::TextBoxTabPageConstructor* __vwsnthis_0; - - __vwsnf139_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0); - - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; - }; - struct __vwsnf13_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__ { ::demo::DataGridTabPageConstructor* __vwsnthis_0; @@ -2043,7 +2058,7 @@ Closures __vwsnf140_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0); - void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; + void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; }; struct __vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__ @@ -2052,7 +2067,7 @@ Closures __vwsnf141_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0); - void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; + void operator()(const ::vl::reflection::description::Value& __vwsn_value_) const; }; struct __vwsnf142_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__ @@ -2061,7 +2076,7 @@ Closures __vwsnf142_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0); - void operator()() const; + void operator()(::vl::presentation::compositions::GuiGraphicsComposition* sender, ::vl::presentation::compositions::GuiEventArgs* arguments) const; }; struct __vwsnf143_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__ @@ -2073,6 +2088,15 @@ Closures void operator()() const; }; + struct __vwsnf144_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__ + { + ::demo::TextBoxTabPageConstructor* __vwsnthis_0; + + __vwsnf144_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance__(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0); + + void operator()() const; + }; + struct __vwsnf14_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance__ { ::demo::DataGridTabPageConstructor* __vwsnthis_0; @@ -3419,14 +3443,14 @@ Closures bool Close() override; }; - class __vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::demo::DateEditorConstructor* __vwsnthis_0; + ::demo::RepeatTabPageConstructor* __vwsnthis_0; - __vwsnc36_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::DateEditorConstructor* __vwsnctorthis_0); + __vwsnc36_Demo_demo_RepeatTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::RepeatTabPageConstructor* __vwsnctorthis_0); - ::demo::DateEditor* __vwsn_bind_cache_0 = nullptr; + ::vl::presentation::controls::GuiScroll* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -3444,7 +3468,7 @@ Closures __vwsnc37_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::DateEditorConstructor* __vwsnctorthis_0); - ::vl::presentation::controls::GuiDateComboBox* __vwsn_bind_cache_0 = nullptr; + ::demo::DateEditor* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -3455,14 +3479,14 @@ Closures bool Close() override; }; - class __vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::demo::DateFilterConstructor* __vwsnthis_0; + ::demo::DateEditorConstructor* __vwsnthis_0; - __vwsnc38_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::DateFilterConstructor* __vwsnctorthis_0); + __vwsnc38_Demo_demo_DateEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::DateEditorConstructor* __vwsnctorthis_0); - ::vl::presentation::controls::GuiSelectableButton* __vwsn_bind_cache_0 = nullptr; + ::vl::presentation::controls::GuiDateComboBox* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -3502,23 +3526,41 @@ Closures ::vl::vint Compare(const ::vl::reflection::description::Value& __vwsn_row1_, const ::vl::reflection::description::Value& __vwsn_row2_) override; }; - class __vwsnc40_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter : public ::vl::Object, public virtual ::vl::presentation::controls::list::IDataFilter + class __vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::demo::DateFilterConstructor* __vwsnthis_0; + + __vwsnc40_Demo_demo_DateFilterConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::DateFilterConstructor* __vwsnctorthis_0); + + ::vl::presentation::controls::GuiSelectableButton* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc41_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter : public ::vl::Object, public virtual ::vl::presentation::controls::list::IDataFilter { public: ::demo::DateFilter* __vwsnthis_0; - __vwsnc40_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter(::demo::DateFilter* __vwsnctorthis_0); + __vwsnc41_Demo_demo_DateFilter___vwsn_instance_ctor___vl_presentation_controls_list_IDataFilter(::demo::DateFilter* __vwsnctorthis_0); void SetCallback(::vl::presentation::controls::list::IDataProcessorCallback* value) override; bool Filter(const ::vl::reflection::description::Value& row) override; }; - class __vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::demo::TextEditorConstructor* __vwsnthis_0; - __vwsnc41_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextEditorConstructor* __vwsnctorthis_0); + __vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextEditorConstructor* __vwsnctorthis_0); ::demo::TextEditor* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -3531,12 +3573,12 @@ Closures bool Close() override; }; - class __vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::demo::TextEditorConstructor* __vwsnthis_0; - __vwsnc42_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextEditorConstructor* __vwsnctorthis_0); + __vwsnc43_Demo_demo_TextEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextEditorConstructor* __vwsnctorthis_0); ::vl::presentation::controls::GuiSinglelineTextBox* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -3549,24 +3591,6 @@ Closures bool Close() override; }; - class __vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::demo::CategoryDisplayerConstructor* __vwsnthis_0; - - __vwsnc43_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0); - - ::demo::CategoryDisplayer* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(); - bool Open() override; - bool Update() override; - bool Close() override; - }; - class __vwsnc44_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: @@ -3597,20 +3621,20 @@ Closures bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + void __vwsn_bind_callback_0_0(); bool Open() override; bool Update() override; bool Close() override; }; - class __vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: - ::demo::CategoryEditorConstructor* __vwsnthis_0; + ::demo::CategoryDisplayerConstructor* __vwsnthis_0; - __vwsnc46_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryEditorConstructor* __vwsnctorthis_0); + __vwsnc46_Demo_demo_CategoryDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryDisplayerConstructor* __vwsnctorthis_0); - ::demo::CategoryEditor* __vwsn_bind_cache_0 = nullptr; + ::demo::CategoryDisplayer* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -3628,6 +3652,24 @@ Closures __vwsnc47_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryEditorConstructor* __vwsnctorthis_0); + ::demo::CategoryEditor* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::demo::CategoryEditorConstructor* __vwsnthis_0; + + __vwsnc48_Demo_demo_CategoryEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryEditorConstructor* __vwsnctorthis_0); + ::vl::presentation::controls::GuiComboBoxListControl* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; bool __vwsn_bind_opened_ = false; @@ -3639,12 +3681,12 @@ Closures bool Close() override; }; - class __vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::demo::CategoryItemTemplateConstructor* __vwsnthis_0; - __vwsnc48_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryItemTemplateConstructor* __vwsnctorthis_0); + __vwsnc49_Demo_demo_CategoryItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryItemTemplateConstructor* __vwsnctorthis_0); ::demo::CategoryItemTemplate* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -3657,24 +3699,6 @@ Closures bool Close() override; }; - class __vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription - { - public: - ::demo::CategoryVisualizerConstructor* __vwsnthis_0; - - __vwsnc49_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryVisualizerConstructor* __vwsnctorthis_0); - - ::demo::CategoryVisualizer* __vwsn_bind_cache_0 = nullptr; - ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; - bool __vwsn_bind_opened_ = false; - bool __vwsn_bind_closed_ = false; - void __vwsn_bind_activator_(); - void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); - bool Open() override; - bool Update() override; - bool Close() override; - }; - class __vwsnc4_Demo_demo_DataGridTabPageConstructor___vwsn_initialize_instance___vl_presentation_controls_list_IDataSorter : public ::vl::Object, public virtual ::vl::presentation::controls::list::IDataSorter { public: @@ -3704,12 +3728,30 @@ Closures bool Close() override; }; - class __vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + { + public: + ::demo::CategoryVisualizerConstructor* __vwsnthis_0; + + __vwsnc51_Demo_demo_CategoryVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::CategoryVisualizerConstructor* __vwsnctorthis_0); + + ::demo::CategoryVisualizer* __vwsn_bind_cache_0 = nullptr; + ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; + bool __vwsn_bind_opened_ = false; + bool __vwsn_bind_closed_ = false; + void __vwsn_bind_activator_(); + void __vwsn_bind_callback_0_0(::vl::presentation::compositions::GuiGraphicsComposition* __vwsn_bind_callback_argument_0, ::vl::presentation::compositions::GuiEventArgs* __vwsn_bind_callback_argument_1); + bool Open() override; + bool Update() override; + bool Close() override; + }; + + class __vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::demo::GenderDisplayerConstructor* __vwsnthis_0; - __vwsnc51_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderDisplayerConstructor* __vwsnctorthis_0); + __vwsnc52_Demo_demo_GenderDisplayerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderDisplayerConstructor* __vwsnctorthis_0); ::demo::GenderDisplayer* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -3722,12 +3764,12 @@ Closures bool Close() override; }; - class __vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::demo::GenderEditorConstructor* __vwsnthis_0; - __vwsnc52_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderEditorConstructor* __vwsnctorthis_0); + __vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderEditorConstructor* __vwsnctorthis_0); ::demo::GenderEditor* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -3740,12 +3782,12 @@ Closures bool Close() override; }; - class __vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::demo::GenderEditorConstructor* __vwsnthis_0; - __vwsnc53_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderEditorConstructor* __vwsnctorthis_0); + __vwsnc54_Demo_demo_GenderEditorConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderEditorConstructor* __vwsnctorthis_0); ::vl::presentation::controls::GuiComboBoxListControl* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -3758,12 +3800,12 @@ Closures bool Close() override; }; - class __vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::demo::GenderVisualizerConstructor* __vwsnthis_0; - __vwsnc54_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderVisualizerConstructor* __vwsnctorthis_0); + __vwsnc55_Demo_demo_GenderVisualizerConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::GenderVisualizerConstructor* __vwsnctorthis_0); ::demo::GenderVisualizer* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; @@ -3776,12 +3818,12 @@ Closures bool Close() override; }; - class __vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::demo::RepeatItemTemplateConstructor* __vwsnthis_0; - __vwsnc55_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::RepeatItemTemplateConstructor* __vwsnctorthis_0); + __vwsnc56_Demo_demo_RepeatItemTemplateConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::RepeatItemTemplateConstructor* __vwsnctorthis_0); bool __vwsn_bind_opened_ = false; bool __vwsn_bind_closed_ = false; @@ -3791,12 +3833,12 @@ Closures bool Close() override; }; - class __vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription + class __vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription : public ::vl::Object, public virtual ::vl::reflection::description::IValueSubscription { public: ::demo::TextBoxTabPageConstructor* __vwsnthis_0; - __vwsnc56_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0); + __vwsnc57_Demo_demo_TextBoxTabPageConstructor___vwsn_initialize_instance___vl_reflection_description_IValueSubscription(::demo::TextBoxTabPageConstructor* __vwsnctorthis_0); ::vl::presentation::controls::GuiSinglelineTextBox* __vwsn_bind_cache_0 = nullptr; ::vl::Ptr<::vl::reflection::description::IEventHandler> __vwsn_bind_handler_0_0; diff --git a/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoReflection.cpp b/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoReflection.cpp index 97f4a20b..4cbdb290 100644 --- a/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoReflection.cpp +++ b/Tutorial/GacUI_ControlTemplate/BlackSkin/UI/FullControlTest/Source/DemoReflection.cpp @@ -593,13 +593,22 @@ namespace vl CLASS_MEMBER_FIELD(__vwsn_precompile_21) CLASS_MEMBER_FIELD(__vwsn_precompile_22) CLASS_MEMBER_FIELD(__vwsn_precompile_23) + CLASS_MEMBER_FIELD(__vwsn_precompile_24) + CLASS_MEMBER_FIELD(__vwsn_precompile_25) + CLASS_MEMBER_FIELD(__vwsn_precompile_26) + CLASS_MEMBER_FIELD(__vwsn_precompile_27) + CLASS_MEMBER_FIELD(__vwsn_precompile_28) + CLASS_MEMBER_FIELD(__vwsn_precompile_29) CLASS_MEMBER_FIELD(__vwsn_precompile_3) + CLASS_MEMBER_FIELD(__vwsn_precompile_30) + CLASS_MEMBER_FIELD(__vwsn_precompile_31) CLASS_MEMBER_FIELD(__vwsn_precompile_4) CLASS_MEMBER_FIELD(__vwsn_precompile_5) CLASS_MEMBER_FIELD(__vwsn_precompile_6) CLASS_MEMBER_FIELD(__vwsn_precompile_7) CLASS_MEMBER_FIELD(__vwsn_precompile_8) CLASS_MEMBER_FIELD(__vwsn_precompile_9) + CLASS_MEMBER_FIELD(hTracker) CLASS_MEMBER_FIELD(repeatFlow) CLASS_MEMBER_FIELD(repeatStack) CLASS_MEMBER_FIELD(self) diff --git a/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin b/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin index 72d09ad1..038c33fa 100644 Binary files a/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin and b/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin differ