@onekeyfe/react-native-perp-depth-bar 3.0.39

package/ios/HybridPerpDepthBars.swift

@@ -0,0 +1,148 @@
+import Foundation
+import UIKit
+
+/// Renders an entire column of order-book depth bars for one side (asks/bids).
+/// Each row is a CALayer whose horizontal `scaleX` fill is animated on the UI
+/// thread, replacing N reanimated `DepthBar` instances.
+final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
+
+  // MARK: - HybridView
+  var view: UIView = PerpLayoutView()
+
+  // MARK: - Per-row fill layers
+  private var barLayers: [CALayer] = []
+
+  // MARK: - State for animation decisions
+  private var lastPercents: [Double] = []
+  private var lastEpoch: Double = .nan
+  private var hasLaidOut = false
+
+  // MARK: - Props (required props -> non-optional in generated spec)
+  var percents: [Double] = [] { didSet { scheduleLayout() } }
+  var rowHeight: Double = 0 { didSet { scheduleLayout() } }
+  var rowMarginTop: Double = 0 { didSet { scheduleLayout() } }
+  var barInset: Double = 0 { didSet { scheduleLayout() } }
+  var origin: String = "left" { didSet { scheduleLayout() } }
+  var reducedMotion: Bool = false { didSet { scheduleLayout() } }
+  var epoch: Double = 0 { didSet { scheduleLayout() } }
+
+  var color: String = "" {
+    didSet {
+      cachedColor = PerpColorParser.parse(color).cgColor
+      applyColorToLayers()
+    }
+  }
+  private var cachedColor: CGColor = UIColor.clear.cgColor
+
+  // MARK: - Init
+  override init() {
+    super.init()
+    view.isUserInteractionEnabled = false // taps handled by RN overlay
+    view.clipsToBounds = true
+    if let layoutView = view as? PerpLayoutView {
+      layoutView.onLayout = { [weak self] in self?.performLayout() }
+    }
+  }
+
+  private func scheduleLayout() {
+    view.setNeedsLayout()
+  }
+
+  // MARK: - Layout + animation
+  private func performLayout() {
+    let bounds = view.bounds
+    guard bounds.width > 0 else { return }
+
+    let count = percents.count
+    syncLayerCount(count)
+
+    // Decide whether this update should animate or snap.
+    let epochChanged = epoch != lastEpoch
+    let countChanged = lastPercents.count != count
+    let snap = !hasLaidOut || reducedMotion || epochChanged || countChanged
+
+    let rowW = bounds.width
+    let h = CGFloat(rowHeight)
+    let inset = CGFloat(barInset)
+    let barH = max(h - inset * 2, 0)
+    let isRight = origin == "right"
+    let anchorX: CGFloat = isRight ? 1 : 0
+
+    CATransaction.begin()
+    CATransaction.setDisableActions(true) // suppress implicit anims for geometry
+
+    for i in 0..<count {
+      let layer = barLayers[i]
+      let rowTop = CGFloat(rowMarginTop) + CGFloat(i) * (h + CGFloat(rowMarginTop))
+      let rowCenterY = rowTop + h / 2
+
+      layer.anchorPoint = CGPoint(x: anchorX, y: 0.5)
+      layer.bounds = CGRect(x: 0, y: 0, width: rowW, height: barH)
+      layer.position = CGPoint(x: isRight ? rowW : 0, y: rowCenterY)
+      layer.backgroundColor = cachedColor
+
+      let target = clampScale(percents[i])
+      let changed = i >= lastPercents.count || lastPercents[i] != percents[i]
+
+      if snap || !changed {
+        layer.removeAnimation(forKey: "fill")
+        layer.transform = CATransform3DMakeScale(target, 1, 1)
+      } else {
+        animateScaleX(layer: layer, to: target)
+      }
+    }
+
+    CATransaction.commit()
+
+    lastPercents = percents
+    lastEpoch = epoch
+    hasLaidOut = true
+  }
+
+  private func animateScaleX(layer: CALayer, to target: CGFloat) {
+    // Continue from the on-screen (presentation) value to avoid snap-back when
+    // a new animation starts every tick (~10Hz).
+    let current: CGFloat
+    if let pres = layer.presentation() {
+      current = pres.value(forKeyPath: "transform.scale.x") as? CGFloat
+        ?? (layer.value(forKeyPath: "transform.scale.x") as? CGFloat ?? target)
+    } else {
+      current = layer.value(forKeyPath: "transform.scale.x") as? CGFloat ?? target
+    }
+
+    layer.transform = CATransform3DMakeScale(target, 1, 1) // model = final
+
+    let anim = CABasicAnimation(keyPath: "transform.scale.x")
+    anim.fromValue = current
+    anim.toValue = target
+    anim.duration = PerpTiming.depthBarDurationMs / 1000.0
+    anim.timingFunction = PerpTiming.easeOutCubic()
+    anim.isRemovedOnCompletion = true
+    layer.add(anim, forKey: "fill")
+  }
+
+  private func syncLayerCount(_ count: Int) {
+    if barLayers.count < count {
+      for _ in barLayers.count..<count {
+        let l = CALayer()
+        l.backgroundColor = cachedColor
+        view.layer.addSublayer(l)
+        barLayers.append(l)
+      }
+    } else if barLayers.count > count {
+      for l in barLayers[count...] { l.removeFromSuperlayer() }
+      barLayers.removeLast(barLayers.count - count)
+    }
+  }
+
+  private func applyColorToLayers() {
+    CATransaction.begin()
+    CATransaction.setDisableActions(true)
+    for l in barLayers { l.backgroundColor = cachedColor }
+    CATransaction.commit()
+  }
+
+  private func clampScale(_ percent: Double) -> CGFloat {
+    CGFloat(max(0, min(100, percent)) / 100.0)
+  }
+}

package/ios/HybridPerpSideRatio.swift

@@ -0,0 +1,118 @@
+import Foundation
+import UIKit
+
+/// Two horizontal segments whose widths animate to the bid/ask ratio.
+final class HybridPerpSideRatio: HybridPerpSideRatioSpec {
+
+  // MARK: - HybridView
+  var view: UIView = PerpLayoutView()
+
+  private let bidLayer = CALayer()
+  private let askLayer = CALayer()
+  private var hasLaidOut = false
+
+  // MARK: - Props
+  var bidPercentage: Double = 50 { didSet { scheduleLayout() } }
+  var askPercentage: Double = 50 { didSet { scheduleLayout() } }
+  var segmentHeight: Double = 4 { didSet { scheduleLayout() } }
+  var cornerRadius: Double = 999 { didSet { scheduleLayout() } }
+  var gap: Double = 2 { didSet { scheduleLayout() } }
+  var reducedMotion: Bool = false { didSet { scheduleLayout() } }
+
+  var longColor: String = "" {
+    didSet {
+      bidLayer.backgroundColor = PerpColorParser.parse(longColor).cgColor
+    }
+  }
+  var shortColor: String = "" {
+    didSet {
+      askLayer.backgroundColor = PerpColorParser.parse(shortColor).cgColor
+    }
+  }
+
+  override init() {
+    super.init()
+    view.isUserInteractionEnabled = false
+    view.clipsToBounds = true
+    bidLayer.maskedCorners = [.layerMinXMinYCorner, .layerMinXMaxYCorner]
+    askLayer.maskedCorners = [.layerMaxXMinYCorner, .layerMaxXMaxYCorner]
+    view.layer.addSublayer(bidLayer)
+    view.layer.addSublayer(askLayer)
+    if let layoutView = view as? PerpLayoutView {
+      layoutView.onLayout = { [weak self] in self?.performLayout() }
+    }
+  }
+
+  private func scheduleLayout() {
+    view.setNeedsLayout()
+  }
+
+  private func performLayout() {
+    let bounds = view.bounds
+    guard bounds.width > 0 else { return }
+
+    let h = CGFloat(segmentHeight)
+    let y = (bounds.height - h) / 2
+    let g = CGFloat(gap)
+    let available = max(bounds.width - g, 0)
+
+    let bid = max(bidPercentage, 1)
+    let ask = max(askPercentage, 1)
+    let total = bid + ask
+    let bidW = available * CGFloat(bid / total)
+    let askW = available - bidW
+    let radius = CGFloat(cornerRadius)
+
+    let bidFrame = CGRect(x: 0, y: y, width: bidW, height: h)
+    let askFrame = CGRect(x: bidW + g, y: y, width: askW, height: h)
+
+    let snap = !hasLaidOut || reducedMotion
+
+    CATransaction.begin()
+    CATransaction.setDisableActions(true)
+    bidLayer.cornerRadius = min(radius, h / 2)
+    askLayer.cornerRadius = min(radius, h / 2)
+    CATransaction.commit()
+
+    if snap {
+      CATransaction.begin()
+      CATransaction.setDisableActions(true)
+      bidLayer.frame = bidFrame
+      askLayer.frame = askFrame
+      CATransaction.commit()
+    } else {
+      animateFrame(layer: bidLayer, to: bidFrame)
+      animateFrame(layer: askLayer, to: askFrame)
+    }
+    hasLaidOut = true
+  }
+
+  private func animateFrame(layer: CALayer, to frame: CGRect) {
+    let duration = PerpTiming.sideRatioDurationMs / 1000.0
+    let timing = PerpTiming.easeOutCubic()
+
+    let fromBounds = layer.presentation()?.bounds ?? layer.bounds
+    let fromPos = layer.presentation()?.position ?? layer.position
+
+    let newBounds = CGRect(x: 0, y: 0, width: frame.width, height: frame.height)
+    let newPos = CGPoint(x: frame.midX, y: frame.midY)
+
+    layer.bounds = newBounds
+    layer.position = newPos
+
+    let boundsAnim = CABasicAnimation(keyPath: "bounds")
+    boundsAnim.fromValue = NSValue(cgRect: fromBounds)
+    boundsAnim.toValue = NSValue(cgRect: newBounds)
+    boundsAnim.duration = duration
+    boundsAnim.timingFunction = timing
+
+    let posAnim = CABasicAnimation(keyPath: "position")
+    posAnim.fromValue = NSValue(cgPoint: fromPos)
+    posAnim.toValue = NSValue(cgPoint: newPos)
+    posAnim.duration = duration
+    posAnim.timingFunction = timing
+
+    layer.add(boundsAnim, forKey: "ratioBounds")
+    layer.add(posAnim, forKey: "ratioPos")
+  }
+}

package/ios/PerpColorParser.swift

@@ -0,0 +1,92 @@
+import Foundation
+import UIKit
+
+/// Parses a color string coming from JS. Supports:
+///   - `#rgb`, `#rrggbb`, `#rrggbbaa`
+///   - `rgb(r, g, b)` / `rgba(r, g, b, a)` where a is 0..1
+/// Falls back to `fallback` on parse failure.
+enum PerpColorParser {
+  static func parse(_ value: String?, fallback: UIColor = .clear) -> UIColor {
+    guard let raw = value?.trimmingCharacters(in: .whitespacesAndNewlines),
+          !raw.isEmpty else {
+      return fallback
+    }
+
+    if raw.hasPrefix("#") {
+      return parseHex(raw) ?? fallback
+    }
+    if raw.lowercased().hasPrefix("rgb") {
+      return parseRGB(raw) ?? fallback
+    }
+    return fallback
+  }
+
+  private static func parseHex(_ hex: String) -> UIColor? {
+    var s = hex
+    s.removeFirst() // '#'
+
+    // Expand shorthand #rgb -> #rrggbb
+    if s.count == 3 {
+      s = s.map { "\($0)\($0)" }.joined()
+    }
+
+    guard s.count == 6 || s.count == 8 else { return nil }
+    var int: UInt64 = 0
+    guard Scanner(string: s).scanHexInt64(&int) else { return nil }
+
+    let r, g, b, a: CGFloat
+    if s.count == 8 {
+      r = CGFloat((int >> 24) & 0xFF) / 255.0
+      g = CGFloat((int >> 16) & 0xFF) / 255.0
+      b = CGFloat((int >> 8) & 0xFF) / 255.0
+      a = CGFloat(int & 0xFF) / 255.0
+    } else {
+      r = CGFloat((int >> 16) & 0xFF) / 255.0
+      g = CGFloat((int >> 8) & 0xFF) / 255.0
+      b = CGFloat(int & 0xFF) / 255.0
+      a = 1.0
+    }
+    return UIColor(red: r, green: g, blue: b, alpha: a)
+  }
+
+  private static func parseRGB(_ value: String) -> UIColor? {
+    guard let open = value.firstIndex(of: "("),
+          let close = value.firstIndex(of: ")") else { return nil }
+    let inner = value[value.index(after: open)..<close]
+    let parts = inner.split(separator: ",").map {
+      $0.trimmingCharacters(in: .whitespaces)
+    }
+    guard parts.count >= 3,
+          let r = Double(parts[0]),
+          let g = Double(parts[1]),
+          let b = Double(parts[2]) else { return nil }
+    let a = parts.count >= 4 ? (Double(parts[3]) ?? 1.0) : 1.0
+    return UIColor(
+      red: CGFloat(r) / 255.0,
+      green: CGFloat(g) / 255.0,
+      blue: CGFloat(b) / 255.0,
+      alpha: CGFloat(a)
+    )
+  }
+}
+
+/// Matches the JS `cubic-bezier(0.33, 1, 0.68, 1)` (Easing.out(cubic)) curve.
+enum PerpTiming {
+  static let depthBarDurationMs: Double = 260
+  static let sideRatioDurationMs: Double = 300
+
+  static func easeOutCubic() -> CAMediaTimingFunction {
+    CAMediaTimingFunction(controlPoints: 0.33, 1, 0.68, 1)
+  }
+}
+
+/// UIView subclass that forwards `layoutSubviews` to a callback so a Nitro
+/// HybridView can re-lay-out its CALayers when bounds change.
+final class PerpLayoutView: UIView {
+  var onLayout: (() -> Void)?
+
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    onLayout?()
+  }
+}

package/lib/module/PerpDepthBars.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=PerpDepthBars.nitro.js.map

package/lib/module/PerpDepthBars.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["PerpDepthBars.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/PerpSideRatio.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=PerpSideRatio.nitro.js.map

package/lib/module/PerpSideRatio.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["PerpSideRatio.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+import { getHostComponent } from 'react-native-nitro-modules';
+const PerpDepthBarsConfig = require('../nitrogen/generated/shared/json/PerpDepthBarsConfig.json');
+const PerpSideRatioConfig = require('../nitrogen/generated/shared/json/PerpSideRatioConfig.json');
+export const PerpDepthBarsView = getHostComponent('PerpDepthBars', () => PerpDepthBarsConfig);
+export const PerpSideRatioView = getHostComponent('PerpSideRatio', () => PerpSideRatioConfig);
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getHostComponent","PerpDepthBarsConfig","require","PerpSideRatioConfig","PerpDepthBarsView","PerpSideRatioView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,gBAAgB,QAAQ,4BAA4B;AAW7D,MAAMC,mBAAmB,GAAGC,OAAO,CAAC,4DAA4D,CAAC;AACjG,MAAMC,mBAAmB,GAAGD,OAAO,CAAC,4DAA4D,CAAC;AASjG,OAAO,MAAME,iBAAiB,GAAGJ,gBAAgB,CAG/C,eAAe,EAAE,MAAMC,mBAAmB,CAAC;AAE7C,OAAO,MAAMI,iBAAiB,GAAGL,gBAAgB,CAG/C,eAAe,EAAE,MAAMG,mBAAmB,CAAC","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/nitrogen/generated/android/c++/JHybridPerpDepthBarsSpec.cpp

@@ -0,0 +1,130 @@
+///
+/// JHybridPerpDepthBarsSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridPerpDepthBarsSpec.hpp"
+
+
+
+#include <vector>
+#include <string>
+
+namespace margelo::nitro::perpdepthbar {
+
+  jni::local_ref<JHybridPerpDepthBarsSpec::jhybriddata> JHybridPerpDepthBarsSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridPerpDepthBarsSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridPerpDepthBarsSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridPerpDepthBarsSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridPerpDepthBarsSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridPerpDepthBarsSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::vector<double> JHybridPerpDepthBarsSpec::getPercents() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayDouble>()>("getPercents");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<double> __vector(__size);
+      __result->getRegion(0, __size, __vector.data());
+      return __vector;
+    }();
+  }
+  void JHybridPerpDepthBarsSpec::setPercents(const std::vector<double>& percents) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayDouble> /* percents */)>("setPercents");
+    method(_javaPart, [&]() {
+      size_t __size = percents.size();
+      jni::local_ref<jni::JArrayDouble> __array = jni::JArrayDouble::newArray(__size);
+      __array->setRegion(0, __size, percents.data());
+      return __array;
+    }());
+  }
+  double JHybridPerpDepthBarsSpec::getRowHeight() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getRowHeight");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridPerpDepthBarsSpec::setRowHeight(double rowHeight) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* rowHeight */)>("setRowHeight");
+    method(_javaPart, rowHeight);
+  }
+  double JHybridPerpDepthBarsSpec::getRowMarginTop() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getRowMarginTop");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridPerpDepthBarsSpec::setRowMarginTop(double rowMarginTop) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* rowMarginTop */)>("setRowMarginTop");
+    method(_javaPart, rowMarginTop);
+  }
+  double JHybridPerpDepthBarsSpec::getBarInset() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getBarInset");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridPerpDepthBarsSpec::setBarInset(double barInset) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* barInset */)>("setBarInset");
+    method(_javaPart, barInset);
+  }
+  std::string JHybridPerpDepthBarsSpec::getColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridPerpDepthBarsSpec::setColor(const std::string& color) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* color */)>("setColor");
+    method(_javaPart, jni::make_jstring(color));
+  }
+  std::string JHybridPerpDepthBarsSpec::getOrigin() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getOrigin");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridPerpDepthBarsSpec::setOrigin(const std::string& origin) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* origin */)>("setOrigin");
+    method(_javaPart, jni::make_jstring(origin));
+  }
+  bool JHybridPerpDepthBarsSpec::getReducedMotion() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getReducedMotion");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridPerpDepthBarsSpec::setReducedMotion(bool reducedMotion) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* reducedMotion */)>("setReducedMotion");
+    method(_javaPart, reducedMotion);
+  }
+  double JHybridPerpDepthBarsSpec::getEpoch() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getEpoch");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridPerpDepthBarsSpec::setEpoch(double epoch) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* epoch */)>("setEpoch");
+    method(_javaPart, epoch);
+  }
+
+  // Methods
+  
+
+} // namespace margelo::nitro::perpdepthbar

package/lib/nitrogen/generated/android/c++/JHybridPerpDepthBarsSpec.hpp

@@ -0,0 +1,80 @@
+///
+/// HybridPerpDepthBarsSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridPerpDepthBarsSpec.hpp"
+
+
+
+
+namespace margelo::nitro::perpdepthbar {
+
+  using namespace facebook;
+
+  class JHybridPerpDepthBarsSpec: public jni::HybridClass<JHybridPerpDepthBarsSpec, JHybridObject>,
+                                  public virtual HybridPerpDepthBarsSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/perpdepthbar/HybridPerpDepthBarsSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridPerpDepthBarsSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridPerpDepthBarsSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridPerpDepthBarsSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridPerpDepthBarsSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::vector<double> getPercents() override;
+    void setPercents(const std::vector<double>& percents) override;
+    double getRowHeight() override;
+    void setRowHeight(double rowHeight) override;
+    double getRowMarginTop() override;
+    void setRowMarginTop(double rowMarginTop) override;
+    double getBarInset() override;
+    void setBarInset(double barInset) override;
+    std::string getColor() override;
+    void setColor(const std::string& color) override;
+    std::string getOrigin() override;
+    void setOrigin(const std::string& origin) override;
+    bool getReducedMotion() override;
+    void setReducedMotion(bool reducedMotion) override;
+    double getEpoch() override;
+    void setEpoch(double epoch) override;
+
+  public:
+    // Methods
+    
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridPerpDepthBarsSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::perpdepthbar