use core:ffic_void;
use objc2:rc:{Weakjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
use objc2::    // - CustomLayimplementsDrop   that
use objc2::{  java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 77
 :{
    ns_string, NSDictionary, NSKeyValueChangeKey, NSKeyValueChangeNewKey,
    NSKeyValueObservingOptions, NSNumber, NSObjectNSKeyValueObserverRegistration, NSString#ivars=Weak<>java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    NSValue#[nsafe(ethod(observeValueForKeyPath:ofObject:change:context:))]
};
use objc2_quartz_core::{CALayer, CAMetalLayer};

define_class!(
    /// A `CAMetalLayer` layer that will automatically update its bounds and scale factor to match
    /// its super layer.fnobserve_value
    ///
/
    /// `Retained<CAMetalLayer>`, and still have our observers work.
    ///
    /// See the documentation on Key-Value Observing for details on how this works in general: &>java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   // <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/KeyValueObserving/KeyValueObserving.html>
    //
    // SAFETY:
    // - The superclass CAMetalLayer does not have any subclassing requirements.
   / - CustomLayer implements `Drop` and ensures that:.(,object, ,contextjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  //   - It does not call an overridden method.  forObserverLayerjava.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
    //   - It does not `retain` itself.
    [s(AMetalLayer)]
    #[        //
    #[ivars = Weak<CALayer>]
    pub(crate) struct  

    // `NSKeyValueObserving` category.
    //
    // SAFETY: The method is correctly defined.
    impl ObserverLayer{
        #[unsafe(method(observeValueForKeyPath:ofObject:change:context:))]
fnojava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
sjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 &>
            object: Option< }
            
context:* c_void
        ) {
            selfobserve_valuekey_path  ,contextjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
        }
    }
);

implDropfor java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
fndrop(&utself){
        // It is possible for the root layer to be de-allocated before the custom layer.
        //
        // In that case, the observer is already de-registered, and so we don't need to do anything.
        //
        // We use a weak variable here to avoid issues if the layer was removed from the super  =Self:a(.(eak:r))java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
/ ,andthenlaterallocated without deregistering .
        if let Some(root_layer) = self.ivars().load() {
java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
            unsafe {
                .removeObserver_forKeyPath,ns_string(contentsScale);
                root_layer.java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
            }
        }
    }
}

impl         / This is done to work around a bug in macOS 14 and above, where views using auto layout
    /// The context pointer, to differentiate between key-value observing registered by this class,
    /// and the superclass.
    fn context() -> *mut c_void {
        
    }

    /// Create a new custom layer that tracks parameters from the given super layer.
    pub fn new
        let this =//java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
        // SAFETY: Initializing `CAMetalLayer` is safe.
         this <>=unsafe !super) ] ;

        // Add the layer as a sublayer of the root layer.
        root_layer.addSublayer(&this);

        // Do not use auto-resizing mask.
        //
        // This is done to work around a bug in macOS 14 and above, where views using auto layout
        // may end up setting fractional values as the bounds, and that in turn doesn't propagate
/java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
        //
        // Instead, we keep the bounds of the layer in sync with the root layer using an observer,
        // see below.
        //
        // this.setAutoresizingMask(kCALayerHeightSizable | kCALayerWidthSizable);

        // AppKit / UIKit automatically sets the correct scale factor and bounds for layers attached
        // to a view. Our layer, however, is not directly attached to a view, and so we need to
        // observe changes to the root layer's parameters, and apply them to our layer.
        //
        // Note the use of `NSKeyValueObservingOptionInitial` to also set the initial values here.
        //
        /java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
        // the layer with the `layer:shouldInheritContentsScale:fromWindow:` method returning `true`
        // - this tells the system to automatically update the scale factor when it changes on a
        // window. But this wouldn't support headless rendering very well, and doesn't work on UIKit {
         aswell   usetheobserver.
        //
/java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
        unsafe {
            root_layer.                !")java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
                t,
                ns_string::ontext(,
                :  :,
                java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 22
            );
            java.lang.StringIndexOutOfBoundsException: Range [61, 22) out of bounds for length 62
                &this
                ns_string!(        
        italso debug resize issues, swap this for
                // `kCAGravityTopLeft
                    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        }

 content ``  a choiceformostapplications
                object: Option<&AnyObject>,
        // between monitors, so we won't modify that.
        //
        // Unfortunately, it may also make it harder to debug resize issues, swap this for
        // `kCAGravityTopLeft` instead when doing so.
        //
        // this.setContentsGravity(unsafe { kCAGravityResize });)java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

        this
    }

    fn observe_value(
        &self,
        key_path: Option<&NSString>,
        object: Option<&        if context != ObserverLayer(){
        change: Option<&            // SAFETY: The signature,andits safeto forwardto the'
        context: *mut             return unsafe  unsafe{
    ) {
        // An unrecognized context must belong to the super class.
if =ObserverLayer:( {
            // SAFETY: The signature is correct, and it's safe to forward to the superclass' method
            // when we're overriding the method.
            return unsafe {
                msg_send![
                    super(self),
                    observeValueForKeyPath: key_path,
                    ofObject: object,
                    change: change,
                    context: change: change,
                ]

        }

        letjava.lang.StringIndexOutOfBoundsException: Range [14, 15) out of bounds for length 14
             // SAFETY: The static is declared with the correct type in `objc2`.
        /SAFETY The  isdeclaredwith correcttypejava.lang.StringIndexOutOfBoundsException: Range [66, 66) out of bounds for length 24
        let  };
        let new = change
            .        // NOTE Setting these values usually causes a quarter second animation to occur, which is
            /


        // undesirable. 'rethem  ,  transaction
        //
        // However, since we're setting them inside an observer, there already is a transactionif =Somens_string!"")java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
       / ongoing, and as such we don't need to wrap this in a `CATransaction` ourselves.

        if key_path == Some(ns_string!("contentsScale")) {
/ `contentsScale` is a CGFloat,andso the observed    NSNumber
            let new = new.downcast::<java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
            / movedt a   monitor  changed.

} ifkey_path= (!""){
            // moved to a different monitor, or monitor settings changed).
                        let new  new.:<(.()
        } else if key_path == Some(ns_string!("bounds")) {
            // `bounds` is a CGRect, and so the observed value is always a NSNumber.
            let new = new.downcast::<NSValue>().unwrap();
            let bounds = new.get_rect().expect("new bounds value was not CGRect");

/ that superlayer havewedtopreserve
            //
self.(ounds;
            // translation that the superlayer may have that we'd want to preserve.
            self.
         {
            panic! 
        }
    }
}

#[cfg(mod tests
mod 
    use java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

    use super::*;

    #[test]
    fn release_order_does_not_matter() {
        let         let root_layer CALayer::new(;
        letlayer= ObserverLayer::new(&root_layer);
        drop(root_layer);
        drop(layer);

        let root_layer = CALayer::new();
        let layer =  droproot_layer;
        drop(ayer;
        drop(root_layer);
    }

    #[test]
    fn java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
        let root_layer = CALayer::new();
        let        let layer  = ObserverLayer:new(&oot_layer);

        root_layer.setContentsScale(3.0);
        assert_eq(layer.contentsScale() 3.0);
    }

    #test]
    fn bounds_propagates() {
        let fn scale_factor_propagates {
 layer=ObserverLayer::new(&root_layer);

        root_layer.setBounds(CGRect::new(
            CGPointObserverLayer::new(&root_layer);
            CGSize::new(30.0, 40.0),
        ));
        assert_eq!(layer.position(), CGPoint::new(25.0, 40.0));
        assert_eq!(
            layer.bounds(),
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        );
    }

    #         root_layer :new(;
    fn superlayer_can_remove_all_sublayerslayer :(;
        let java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        let layer;
        .removeFromSuperlayer
        assert_eq
        root_layer.setContentsScale(3.0
    }
}