Adoption (#660)

* adoption

* hopefully fixed broken AUI_DECLARATIVE_FOR

* update Devtools::prettyName

* fix android and ios

* u

* fix tests

Author: Alex2772

aui.core/src/AUI/Common/AUuid.h

@@ -106,6 +106,14 @@ inline std::ostream& operator<<(std::ostream& o, const AUuid& u) {
     return o;
 }
 
+template <>
+struct fmt::formatter<AUuid> : fmt::formatter<AString> {
+    template <typename FormatContext>
+    auto format(const AUuid& uuid, FormatContext& ctx) const {
+        return fmt::formatter<AString>::format(uuid.toString(), ctx);
+    }
+};
+
 
 class AUuidException: public AException {
 private:

aui.core/src/AUI/Hash.h

@@ -0,0 +1,146 @@
+// AUI Framework - Declarative UI toolkit for modern C++20
+// Copyright (C) 2020-2025 Alex2772 and Contributors
+//
+// SPDX-License-Identifier: MPL-2.0
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include <map>
+
+namespace aui {
+
+namespace hash_detail {
+
+template <std::size_t Bits>
+struct hash_mix_impl;
+
+// hash_mix for 64 bit size_t
+//
+// The general "xmxmx" form of state of the art 64 bit mixers originates
+// from Murmur3 by Austin Appleby, which uses the following function as
+// its "final mix":
+//
+//	k ^= k >> 33;
+//	k *= 0xff51afd7ed558ccd;
+//	k ^= k >> 33;
+//	k *= 0xc4ceb9fe1a85ec53;
+//	k ^= k >> 33;
+//
+// (https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp)
+//
+// It has subsequently been improved multiple times by different authors
+// by changing the constants. The most well known improvement is the
+// so-called "variant 13" function by David Stafford:
+//
+//	k ^= k >> 30;
+//	k *= 0xbf58476d1ce4e5b9;
+//	k ^= k >> 27;
+//	k *= 0x94d049bb133111eb;
+//	k ^= k >> 31;
+//
+// (https://zimbry.blogspot.com/2011/09/better-bit-mixing-improving-on.html)
+//
+// This mixing function is used in the splitmix64 RNG:
+// http://xorshift.di.unimi.it/splitmix64.c
+//
+// We use Jon Maiga's implementation from
+// http://jonkagstrom.com/mx3/mx3_rev2.html
+//
+// 	x ^= x >> 32;
+//	x *= 0xe9846af9b1a615d;
+//	x ^= x >> 32;
+//	x *= 0xe9846af9b1a615d;
+//	x ^= x >> 28;
+//
+// An equally good alternative is Pelle Evensen's Moremur:
+//
+//	x ^= x >> 27;
+//	x *= 0x3C79AC492BA7B653;
+//	x ^= x >> 33;
+//	x *= 0x1C69B3F74AC4AE35;
+//	x ^= x >> 27;
+//
+// (https://mostlymangling.blogspot.com/2019/12/stronger-better-morer-moremur-better.html)
+
+template <>
+struct hash_mix_impl<64> {
+    inline static std::uint64_t fn(std::uint64_t x) {
+        std::uint64_t const m = (static_cast<std::uint64_t>(0xe9846af) << 32) + 0x9b1a615d;
+
+        x ^= x >> 32;
+        x *= m;
+        x ^= x >> 32;
+        x *= m;
+        x ^= x >> 28;
+
+        return x;
+    }
+};
+
+// hash_mix for 32 bit size_t
+//
+// We use the "best xmxmx" implementation from
+// https://github.com/skeeto/hash-prospector/issues/19
+
+template <>
+struct hash_mix_impl<32> {
+    inline static std::uint32_t fn(std::uint32_t x) {
+        std::uint32_t const m1 = 0x21f0aaad;
+        std::uint32_t const m2 = 0x735a2d97;
+
+        x ^= x >> 16;
+        x *= m1;
+        x ^= x >> 15;
+        x *= m2;
+        x ^= x >> 15;
+
+        return x;
+    }
+};
+
+inline std::size_t hash_mix(std::size_t v) { return hash_mix_impl<sizeof(std::size_t) * CHAR_BIT>::fn(v); }
+
+}   // namespace hash_detail
+
+//
+// boost::hash_combine
+//
+
+template <class T>
+inline void hash_combine(std::size_t& seed, T const& v) {
+    seed = aui::hash_detail::hash_mix(seed + 0x9e3779b9 + std::hash<T>()(v));
+}
+
+namespace hash_detail {
+template <class It>
+inline std::size_t hash_range(std::size_t seed, It first, It last) {
+    for (; first != last; ++first) {
+        hash_combine<typename std::iterator_traits<It>::value_type>(seed, *first);
+    }
+
+    return seed;
+}
+}
+
+//
+// boost::hash_range
+//
+
+template <class It>
+inline void hash_range(std::size_t& seed, It first, It last) {
+    seed = hash_detail::hash_range(seed, first, last);
+}
+
+template <class It>
+inline std::size_t hash_range(It first, It last) {
+    std::size_t seed = 0;
+
+    hash_range(seed, first, last);
+
+    return seed;
+}
+}   // namespace aui

aui.uitests/tests/UIDeclarativeForTest.cpp

@@ -379,10 +379,7 @@ TEST_F(UIDeclarativeForTest, Reactive_lists) { // HEADER_H3
 }
 
 TEST_F(UIDeclarativeForTest, DynamicPerformance) {
-    struct State {
-        AProperty<AVector<AString>> items = AVector<AString> { "Hello", "World", "Test" };
-    };
-    auto state = _new<State>();
+
 
     ::testing::GTEST_FLAG(throw_on_failure) = true;
 
@@ -392,18 +389,72 @@ TEST_F(UIDeclarativeForTest, DynamicPerformance) {
     EXPECT_CALL(mTestObserver, onViewCreated("Test"_as));
     EXPECT_CALL(mTestObserver, onViewCreated("Bruh"_as));
 
+    // ## View caching { #AFOREACHUI_CACHING }
+    //
+    // By default, AForEachUI does not cache instantiated views. This means that every time the underlying model is
+    // changed, all views are destroyed and recreated. This is not efficient in many scenarios, especially when views are
+    // complex and model changes are small.
+    //
+    // To enable view caching, you need to provide a *key function* that generates a unique key for each item in the
+    // model. The key function is a lambda that takes an item and returns a `std::size_t` hash of the value.
+    //
+    // AUI_DOCS_CODE_BEGIN
+    struct State {
+        AProperty<AVector<AString>> items = AVector<AString> { "Hello", "World", "Test" };
+    };
+    auto state = _new<State>();
+
+    auto testObserver = &mTestObserver;
+
     mWindow->setContents(Vertical {
       AScrollArea::Builder()
               .withContents(
-              AUI_DECLARATIVE_FOR_EX(i, *state->items, AVerticalLayout, &) {
-                  mTestObserver.onViewCreated(i);
+              AUI_DECLARATIVE_FOR(i, *state->items, AVerticalLayout) {
+                  testObserver->onViewCreated(i); // HIDE
+                  ALogger::info("Test") << "Created view: " << i;
                   return Label { i };
+              } AUI_LET {
+                  it->setKeyFunction([](const AString& k) {
+                      return std::hash<AString>{}(k);
+                  });
               })
               .build() AUI_OVERRIDE_STYLE { FixedSize { 150_dp, 200_dp } },
     });
+    // AUI_DOCS_CODE_END
+    saveScreenshot("1");
+    //
+    // <figure markdown="span">
+    // ![](imgs/UIDeclarativeForTest.DynamicPerformance_1.png){ width="500" }
+    // <figcaption>Basic view caching example.</figcaption>
+    // </figure>
+    //
+    //
+    // ``` title="Possible output"
+    // [07:09:06][][Test][INFO]: Created view: Hello
+    // [07:09:06][][Test][INFO]: Created view: World
+    // [07:09:06][][Test][INFO]: Created view: Test
+    // ```
 
     uitest::frame();
+    //
+    // Upon adding a new item to the model, only the new item's view is created. The existing views are reused from
+    // the cache.
+    // AUI_DOCS_CODE_BEGIN
     state->items.writeScope()->push_back("Bruh");
+    // AUI_DOCS_CODE_END
+    //
+    // If we were not using view caching, all views would be recreated:
+    // ``` title="Possible output without view caching"
+    // [07:09:06][][Test][INFO]: Created view: Hello
+    // [07:09:06][][Test][INFO]: Created view: World
+    // [07:09:06][][Test][INFO]: Created view: Test
+    // [07:09:10][][Test][INFO]: Created view: Hello
+    // [07:09:10][][Test][INFO]: Created view: World
+    // [07:09:10][][Test][INFO]: Created view: Test
+    // [07:09:10][][Test][INFO]: Created view: Bruh
+    // ```
+    //
+
     uitest::frame();
     EXPECT_EQ(cache<AForEachUI<AString>>().size(), 0);
 }
@@ -446,6 +497,12 @@ TEST_F(UIDeclarativeForTest, IntGrouping) {
 TEST_F(UIDeclarativeForTest, IntGroupingDynamic1) {
     ::testing::GTEST_FLAG(throw_on_failure) = true;
 
+    //
+    // ### Advanced grouping with caching
+    //
+    // In this example, we demonstrate a more advanced use case of AForEachUI with nested grouping and view caching.
+    // 
+    // AUI_DOCS_CODE_BEGIN
     struct State {
         AProperty<AVector<int>> ints = AVector<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
     };
@@ -471,11 +528,49 @@ TEST_F(UIDeclarativeForTest, IntGroupingDynamic1) {
                               auto str = "{}"_format(i);
                               mTestObserver.onViewCreated(str);
                               return Label { std::move(str) };
+                          } AUI_LET {
+                              it->setKeyFunction([](int k) {
+                                  return k;
+                              });
                           }
                       };
+                  } AUI_LET {
+                      it->setKeyFunction([](const auto& rng) {
+                          return aui::hash_range(ranges::begin(rng), ranges::end(rng));;
+                      });
                   })
               .build() AUI_OVERRIDE_STYLE { FixedSize { 150_dp, 300_dp } },
     });
+    // AUI_DOCS_CODE_END
+    //
+    // In this example, we have a nested AForEachUI structure, where the outer AForEachUI iterates over groups of
+    // integers, and the inner AForEachUI iterates over individual integers within each group.
+    //
+    // <figure markdown="span">
+    // ![](imgs/UIDeclarativeForTest.IntGroupingDynamic1_1.png){ width="500" }
+    // <figcaption>Advanced grouping example.</figcaption>
+    // </figure>
+    //
+    // In addition to user-provided `setKeyFunction` outcome, the key is strengthened with byte-level hash of the item
+    // by the framework. This is required to enforce uniqueness of `ranges::view::chunk` which stores iterator pair to
+    // a generic container.
+    //
+    // ??? "More about byte-level hashing"
+    //
+    //     The goal is to avoid incorrect cache hits (reusing a view for the “wrong” element or group), especially for
+    //     tricky range types like `ranges::views::chunk` that store iterator pairs and are sensitive to container
+    //     mutations.
+    //
+    //     The subrange object (e.g., from `ranges::views::chunk`) contains iterators pointing to the original
+    //     container. If the container is modified (elements added/removed), these iterators may become invalid or
+    //     shifted. Since cached view captures the non-owning subrange object by value, iterating over it later may lead
+    //     to unexpected results.
+    //
+    //     The raw byte-level hash helps to identify underlying iterator changes that may not be reflected in
+    //     user-provided keys, preventing reuse of the stale cached views.
+    //
+    //     The hash enforced by the framework can be customized by specializing `aui::for_each_ui::defaultKey<T>`.
+    // 
 
     EXPECT_CALL(mTestObserver, onViewCreated("Group 0"_as));
     EXPECT_CALL(mTestObserver, onViewCreated("1"_as));
@@ -502,7 +597,14 @@ TEST_F(UIDeclarativeForTest, IntGroupingDynamic1) {
     /* Also, depending on used container's iterator implementation, other groups might be evaluated as well. In our
      * case, we are using AVector, whose iterator is an offset from beginning. Since the offset has changed due to
      * removal, the iterator is considered dirty. This might not be the case for containers whose items are stored in
-     * heap, i.e., `std::list`. */
+     * heap, i.e., `std::list`.
+     *
+     * We need to be especially careful with this. Since we are using ranges::view::chunk in our example, it stores
+     * iterator pair to std::vector. Iterators of std::vector MUST BE invalidated since we have changed the container.
+     *
+     * Given that, we expect "Group 10" to be reevaluated, despite user-provided setKeyFunction outcome would give equal
+     * hashes both before and after removal.
+     */
     EXPECT_CALL(mTestObserver, onViewCreated("Group 10"_as));
     {
         state->ints.writeScope()->removeAll(2);

aui.views/src/AUI/Devtools/Devtools.cpp

@@ -41,7 +41,7 @@ AString Devtools::prettyViewName(AView* view) {
     }
     auto filter = [](const AString& name) { return !name.contains("::detail::"); };
     if (auto rng = view->getAssNames() | ranges::view::filter(filter); !ranges::empty(rng)) {
-        name = ranges::back(rng);
+        name += " " + ranges::back(rng);
     }
     return name;
 }

aui.views/src/AUI/Platform/android/OpenGLRenderingContextImpl.cpp

@@ -22,10 +22,11 @@
 
 #include <AUI/GL/OpenGLRenderer.h>
 #include <AUI/GL/State.h>
-
+#include <EGL/egl.h>
 
 void OpenGLRenderingContext::init(const Init& init) {
     CommonRenderingContext::init(init);
+    gladLoadGLES2Loader(reinterpret_cast<GLADloadproc>(eglGetProcAddress));
     mRenderer = ourRenderer();
 }
 

aui.views/src/AUI/Platform/ios/OpenGLRenderingContextImpl.cpp

@@ -13,6 +13,7 @@
 // Created by Alex2772 on 12/7/2021.
 //
 
+#include <dlfcn.h>
 #include <AUI/GL/gl.h>
 #include <AUI/Platform/OpenGLRenderingContext.h>
 #include <AUI/Util/ARandom.h>
@@ -23,9 +24,18 @@
 #include <AUI/GL/OpenGLRenderer.h>
 #include <AUI/GL/State.h>
 
+static void* UIKit_GL_GetProcAddress(const char *proc)
+{
+    /* Look through all SO's for the proc symbol.  Here's why:
+     * -Looking for the path to the OpenGL Library seems not to work in the iOS Simulator.
+     * -We don't know that the path won't change in the future. */
+    return dlsym(RTLD_DEFAULT, proc);
+}
+
 
 void OpenGLRenderingContext::init(const Init& init) {
     CommonRenderingContext::init(init);
+    gladLoadGLES2Loader(reinterpret_cast<GLADloadproc>(UIKit_GL_GetProcAddress));
     mRenderer = ourRenderer();
 }
 

aui.views/src/AUI/Platform/linux/x11/PlatformAbstractionX11.cpp

@@ -485,8 +485,7 @@ void PlatformAbstractionX11::windowSetGeometry(AWindow& window, int x, int y, in
     if (!nativeHandle(window))
         return;
     WindowStyle style = window.windowStyle();
-    bool isPopupMenu = (style == WindowStyle::DEFAULT) ||
-                 ((style & WindowStyle::SYS) == WindowStyle::SYS);
+    bool isPopupMenu = (style & WindowStyle::SYS) == WindowStyle::SYS;
 
     XWindowChanges changes;
     changes.x = x;