Polish MinZ editor UI and generalize the composite-option walkthrough

Editor UI:
- Make the disabled-state dim more pronounced.
- Disparity Shift/Threshold sliders gain a pencil-icon toggle between
  the slider and a centered, color-matched manual-entry text box
  (ImGui's native Ctrl+Click/double-click text-input proved unreliable
  here), plus Left/Right arrow-key nudging once the slider has focus.
  Both modes call touch() while active so the debounce timer freezes
  during manual edits instead of expiring mid-entry.
- Add a "Reset to Default" button reusing the same debounced-commit
  pipeline as every other field edit, later hidden behind a small "..."
  marker in the box's bottom-right corner - revealed only on hover
  nearby, and drawn on the same line as the last field rather than
  reserving a row of its own, so it may partially overlap that field
  when revealed.
- Fix: changing the Downscale Ratio radio buttons via arrow-key
  navigation didn't start the auto-commit debounce timer the way a
  mouse click did - a discrete edit's touch()+finalize() land in the
  same frame as the deadline-collapsing focus-loss shortcut, which
  couldn't yet tell a fresh discrete edit apart from focus genuinely
  leaving the group; suppressed for the one frame finalize() just ran
  on.
- Keyboard-driven edits (arrow-key slider nudges, and radio-button
  changes via keyboard/gamepad nav) now schedule their auto-commit
  0.1s out instead of the usual 1.7s, since they already land on a
  known, deliberate value one step at a time and don't need the same
  give-me-a-moment-to-change-my-mind pause a mouse edit gets. Mouse
  clicks/drags on the same controls are unaffected.

Examples:
- Generalize the composite-option walkthrough to sweep every embedded
  filter/id on the device rather than just Temporal Filter DPP, with
  dual raw-bytes + typed views and rectangular hex-grid wrapping for
  long buffers.
- Add a pure-C99 demo of the same MinZ get/set walkthrough through the
  raw C API (no exceptions, templates, or RAII), verified end-to-end on
  both Windows and Linux.

Author: Evgeni Raikhel

common/composite-control-editor.h

@@ -107,8 +107,23 @@ namespace rs2
         }
 
         // Call once a field's edit is finalized (slider released, or immediately after a
-        // checkbox/radio click). Schedules the real auto-commit commit_delay seconds out.
-        void finalize() { _commit_deadline = ImGui::GetTime() + commit_delay; }
+        // checkbox/radio click). Schedules the auto-commit out by commit_delay seconds, or by
+        // the much shorter fast_commit_delay when use_fast_delay is set - the caller's own way
+        // of saying "this particular edit came from a keyboard arrow-key nudge, not a mouse
+        // click/drag," which should feel closer to immediate feedback than the deliberate,
+        // give-me-a-moment-to-change-my-mind pause a mouse edit gets.
+        void finalize( bool use_fast_delay = false )
+        {
+            _commit_deadline = ImGui::GetTime() + ( use_fast_delay ? fast_commit_delay : commit_delay );
+            // A discrete edit (radio/checkbox click, keyboard arrow-key nudge) calls touch()+
+            // finalize() together, synchronously, within the SAME frame as the
+            // end_frame_and_maybe_commit() call below that just set this deadline - unlike a
+            // mouse drag, which spans several frames with the widget genuinely active in
+            // between, giving the focus-loss shortcut no chance to fire on that exact frame.
+            // Suppress it for this one frame so it can't immediately collapse the deadline it
+            // was never meant to see yet.
+            _just_finalized = true;
+        }
 
         // Side-effect-free readout of the same progress end_frame_and_maybe_commit() animates
         // with: false if nothing is pending, true with `progress` in [0,1] (0 = just
@@ -185,9 +200,11 @@ namespace rs2
             // normal quiet gap between finishing one field and touching the next one in THIS
             // group, and must NOT cut the wait short). When that happens, don't make the user
             // wait out the rest of the countdown - finish it now, same as if it had lapsed
-            // naturally.
-            if( _dirty && ! any_field_active_this_frame && ImGui::IsAnyItemActive() )
+            // naturally. Skipped on the one frame finalize() just ran on (see its comment) - a
+            // discrete edit's own deadline must survive at least until the NEXT frame.
+            if( _dirty && ! any_field_active_this_frame && ImGui::IsAnyItemActive() && ! _just_finalized )
                 _commit_deadline = ImGui::GetTime();
+            _just_finalized = false;
 
             // Fires once the countdown elapses quietly - checked every frame, so any fresh
             // touch() (which re-parks the deadline at +infinity) naturally defers this for as
@@ -212,8 +229,10 @@ namespace rs2
     private:
         bool _dirty = false;
         double _commit_deadline = std::numeric_limits< double >::max();
+        bool _just_finalized = false;
 
         static constexpr double commit_delay = 1.7;          // seconds of quiet before auto-sending
+        static constexpr double fast_commit_delay = 0.1;     // ditto, for keyboard arrow-key nudges
         static constexpr float border_start_scale = 4.0f;    // 400% of normal width, right after an edit
         static constexpr float border_end_scale = 2.5f;      // 250% of normal width, right before commit
     };

common/embedded-filter-model.cpp

@@ -99,5 +99,14 @@ namespace rs2
         // other multi-param composite option can get the same touch/fade/reset/commit behavior
         // by holding its own composite_control_editor<its-struct-type> the same way.
         composite_control_editor< rs2_minz_control > _minz_editor;
+
+        // Per-field manual-entry toggle state for the Disparity Shift / Threshold sliders (see
+        // draw_minz_control_editor()) - mirrors option_model's own edit_mode/edit_value pattern
+        // (common/option-model.cpp) rather than relying on ImGui's native SliderInt Ctrl+Click/
+        // double-click text-input, which turned out not to be reliably discoverable/usable here.
+        bool _minz_shift_edit_mode = false;
+        std::string _minz_shift_edit_buf;
+        bool _minz_threshold_edit_mode = false;
+        std::string _minz_threshold_edit_buf;
     };
 }

common/embedded-filter-model.h

@@ -5,14 +5,16 @@ cmake_minimum_required(VERSION 3.10)
 project(RealsenseExamplesCompositeOptionWalkthrough)
 
 # PROTOTYPE / DEMO reference sample: a "how do I use the composite-option API" walkthrough,
-# exercising the FULL surface (enumeration, set, get, get_range, metadata queries) against a fake
-# in-memory librealsense::composite_option_interface implementation standing in for real HKR/D555
-# hardware (librealsense::composite_xu_option, src/ds/composite-xu-option.h), which is not present
-# on this dev machine. See rs-hkr-temporal-filter-dpp-mock for the companion round-trip/atomicity
-# proof; this sample is meant to read as documentation for other engineers. Drives everything
-# through the REAL PUBLIC API (rs2::options::get_supported_composite_options()/
-# set_composite_option()/get_composite_option()/get_composite_option_range()/
-# supports_composite_option()/is_composite_option_read_only()/get_composite_option_description()),
+# exercising the FULL surface (enumeration, get, read-modify-write set, get_range, metadata
+# queries) against every composite option found on every embedded filter of every depth sensor of
+# every connected device - no fake/mock transport. Each composite option id found gets its own
+# try/catch, so a control that's registered but non-functional on this device/FW (e.g.
+# RS2_COMPOSITE_OPTION_HKR_TEMPORAL_FILTER_DPP's ctrl_id not being validated against real
+# firmware, see src/ds/d500/d500-factory.cpp's rs555_device comment) is reported per-id rather
+# than aborting the whole walkthrough - see rs-composite-option-walkthrough.cpp for the full
+# sequence and per-id dispatch. Drives everything through the REAL PUBLIC API
+# (rs2::options::get_supported_composite_options()/set_composite_option()/get_composite_option()/
+# get_composite_option_range()/is_composite_option_read_only()/get_composite_option_description()),
 # so it links against realsense2 like any other example.
 add_executable(rs-composite-option-walkthrough
     rs-composite-option-walkthrough.cpp
@@ -22,12 +24,24 @@ target_link_libraries(rs-composite-option-walkthrough PRIVATE ${LRS_TARGET})
 set_target_properties (rs-composite-option-walkthrough PROPERTIES FOLDER Examples)
 install(TARGETS rs-composite-option-walkthrough RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
-# PROTOTYPE / DEMO: HKR MinZ Control, one call at a time, against a REAL connected device (no
-# fake transport) - see rs-minz-control-walkthrough.cpp.
+# PROTOTYPE / DEMO: sweeps every connected device's depth sensor(s), enumerates whichever
+# composite options each one supports, and prints the current value of each - against REAL
+# connected devices (no fake transport). See rs-minz-control-walkthrough.cpp.
 add_executable(rs-minz-control-walkthrough
     rs-minz-control-walkthrough.cpp
 )
 set_property(TARGET rs-minz-control-walkthrough PROPERTY CXX_STANDARD 14)
 target_link_libraries(rs-minz-control-walkthrough PRIVATE ${LRS_TARGET})
 set_target_properties (rs-minz-control-walkthrough PROPERTIES FOLDER Examples)
 install(TARGETS rs-minz-control-walkthrough RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+# PROTOTYPE / DEMO: same MinZ get/set walkthrough, through the raw C API instead of the C++
+# wrapper - no exceptions, no templates, manual struct casts and buffer frees. See
+# rs-composite-option-c99.c.
+add_executable(rs-composite-option-c99
+    rs-composite-option-c99.c
+)
+set_property(TARGET rs-composite-option-c99 PROPERTY C_STANDARD 99)
+target_link_libraries(rs-composite-option-c99 PRIVATE ${LRS_TARGET})
+set_target_properties (rs-composite-option-c99 PROPERTIES FOLDER Examples)
+install(TARGETS rs-composite-option-c99 RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

examples/composite-option-walkthrough/CMakeLists.txt

@@ -0,0 +1,136 @@
+/* License: Apache 2.0. See LICENSE file in root directory. */
+/* Copyright(c) 2026 RealSense, Inc. All Rights Reserved. */
+
+/* C99 version of the composite-option walkthrough - same MinZ get/set, through the raw C API:
+   no exceptions (check rs2_error* after every call), no templates (manual struct/byte casts),
+   no RAII (every list/device/sensor/filter/buffer freed by hand). Main success scenario only. */
+
+#include <librealsense2/rs.h>
+#include <librealsense2/h/rs_hkr_minz_control.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static void check_error( rs2_error * e )
+{
+    if( e )
+    {
+        printf( "error: %s\n", rs2_get_error_message( e ) );
+        rs2_free_error( e );
+        exit( 1 );
+    }
+}
+
+int main( void )
+{
+    rs2_error * e = NULL;
+
+    rs2_context * ctx = rs2_create_context( RS2_API_VERSION, &e );
+    check_error( e );
+
+    rs2_device_list * devices = rs2_query_devices( ctx, &e );
+    check_error( e );
+    int device_count = rs2_get_device_count( devices, &e );
+    check_error( e );
+    printf( "Found %d device(s)\n", device_count );
+    if( device_count == 0 )
+        return 0;
+
+    rs2_device * dev = rs2_create_device( devices, 0, &e );
+    check_error( e );
+
+    rs2_sensor_list * sensors = rs2_query_sensors( dev, &e );
+    check_error( e );
+    int sensor_count = rs2_get_sensors_count( sensors, &e );
+    check_error( e );
+
+    for( int i = 0; i < sensor_count; ++i )
+    {
+        rs2_sensor * sensor = rs2_create_sensor( sensors, i, &e );
+        check_error( e );
+
+        if( ! rs2_is_sensor_extendable_to( sensor, RS2_EXTENSION_DEPTH_SENSOR, &e ) )
+        {
+            check_error( e );
+            rs2_delete_sensor( sensor );
+            continue;
+        }
+        check_error( e );
+
+        rs2_embedded_filter_list * filters = rs2_query_embedded_filters( sensor, &e );
+        check_error( e );
+        int filter_count = rs2_get_embedded_filters_count( filters, &e );
+        check_error( e );
+
+        for( int f = 0; f < filter_count; ++f )
+        {
+            rs2_embedded_filter * filter = rs2_create_embedded_filter( filters, f, &e );
+            check_error( e );
+
+            /* rs2_embedded_filter is-a rs2_options in the underlying C++ implementation
+               (see struct rs2_embedded_filter : public rs2_options in src/rs.cpp) - every
+               composite-option C function takes an rs2_options*, so this cast is valid. */
+            const rs2_options * opts = ( const rs2_options * )filter;
+
+            if( rs2_supports_composite_option( opts, RS2_COMPOSITE_OPTION_HKR_MINZ_CONTROL, &e ) )
+            {
+                check_error( e );
+
+                /* Get - raw bytes, application-side cast (no get_composite_option_as<T>() here). */
+                const rs2_raw_data_buffer * raw = rs2_get_composite_option(
+                    opts, RS2_COMPOSITE_OPTION_HKR_MINZ_CONTROL, &e );
+                check_error( e );
+                int size = rs2_get_raw_data_size( raw, &e );
+                check_error( e );
+                if( (size_t)size != sizeof( rs2_minz_control ) )
+                {
+                    printf( "unexpected payload size: %d\n", size );
+                    exit( 1 );
+                }
+                const unsigned char * bytes = rs2_get_raw_data( raw, &e );
+                check_error( e );
+
+                rs2_minz_control current;
+                memcpy( &current, bytes, sizeof( current ) );
+                rs2_delete_raw_data( raw );
+
+                printf( "Get: enable=%d downscale_ratio=%d disparity_shift=%d threshold=%d threshold_mode=%d\n",
+                        current.enable, current.downscale_ratio, current.disparity_shift,
+                        current.threshold, current.threshold_mode );
+
+                /* Set - read-modify-write, toggle enable, whole struct sent atomically. */
+                rs2_minz_control cfg = current;
+                cfg.enable = ! cfg.enable;
+                rs2_set_composite_option( opts, RS2_COMPOSITE_OPTION_HKR_MINZ_CONTROL, &cfg, sizeof( cfg ), &e );
+                check_error( e );
+                printf( "Set: enable=%d\n", cfg.enable );
+
+                /* Get again to confirm. */
+                raw = rs2_get_composite_option( opts, RS2_COMPOSITE_OPTION_HKR_MINZ_CONTROL, &e );
+                check_error( e );
+                bytes = rs2_get_raw_data( raw, &e );
+                check_error( e );
+                rs2_minz_control after;
+                memcpy( &after, bytes, sizeof( after ) );
+                rs2_delete_raw_data( raw );
+
+                printf( "Get (after): enable=%d downscale_ratio=%d disparity_shift=%d threshold=%d threshold_mode=%d\n",
+                        after.enable, after.downscale_ratio, after.disparity_shift,
+                        after.threshold, after.threshold_mode );
+                printf( "%s\n", after.enable == cfg.enable ? "matches what was sent" : "differs" );
+            }
+
+            rs2_delete_embedded_filter( filter );
+        }
+
+        rs2_delete_embedded_filter_list( filters );
+        rs2_delete_sensor( sensor );
+    }
+
+    rs2_delete_sensor_list( sensors );
+    rs2_delete_device( dev );
+    rs2_delete_device_list( devices );
+    rs2_delete_context( ctx );
+    return 0;
+}