PDF_Office/PDF Office/PDF Master/Class/PDFTools/Snapshot/Window/KMSnapshotWindowController.swift

//
//  KMSnapshotWindowController.swift
//  PDF Master
//
//  Created by tangchao on 2023/12/12.
//

import Cocoa
 
@objc protocol KMSnapshotWindowControllerDelegate: NSObjectProtocol {
    @objc optional func snapshotControllerDidFinishSetup(_ controller: KMSnapshotWindowController)
    @objc optional func snapshotControllerWillClose(_ controller: KMSnapshotWindowController)
    @objc optional func snapshotControllerDidChange(_ controller: KMSnapshotWindowController)
    @objc optional func snapshotController(_ controller: KMSnapshotWindowController, miniaturizedRect isMiniaturize: Bool) -> NSRect
}

class KMSnapshotWindowController: NSWindowController {
    
    @IBOutlet var pdfView: KMSnapshotPDFView!
    
    var hasWindow = false
    var forceOnTop = false
    
    weak var delegate: KMSnapshotWindowControllerDelegate?
    
    var string: String = ""
    
    var pageLabel: String = "" {
        didSet {
            self.synchronizeWindowTitleWithDocumentName()
        }
    }
    
    var animating = false
    var thumbnail: NSImage?
    var windowImage: NSImage?
    
    /*
     extern NSString *SKSnapshotCurrentSetupKey;

     @property (nonatomic, readonly) NSUInteger pageIndex;
     @property (nonatomic, readonly) BOOL hasWindow;
     @property (nonatomic, readonly) NSDictionary *pageAndWindow;
     @property (nonatomic, readonly) NSDictionary *currentSetup;

     @property (nonatomic, readonly) NSAttributedString *thumbnailAttachment, *thumbnail512Attachment, *thumbnail256Attachment, *thumbnail128Attachment, *thumbnail64Attachment, *thumbnail32Attachment;

     - (void)setPdfDocument:(PDFDocument *)pdfDocument goToPageNumber:(NSInteger)pageNum rect:(NSRect)rect scaleFactor:(CGFloat)factor autoFits:(BOOL)autoFits;
     - (void)setPdfDocument:(PDFDocument *)pdfDocument setup:(NSDictionary *)setup;

     - (BOOL)isPageVisible:(PDFPage *)page;

     - (void)redisplay;

     - (NSImage *)thumbnailWithSize:(CGFloat)size;

     - (NSAttributedString *)thumbnailAttachmentWithSize:(CGFloat)size;

     - (void)miniaturize;
     - (void)deminiaturize;

     - (void)handleDocumentDidUnlockNotification:(NSNotification *)notification;
     - (void)handlePDFViewFrameChangedNotification:(NSNotification *)notification;
     - (void)handleViewChangedNotification:(NSNotification *)notification;
     - (void)handleDidAddRemoveAnnotationNotification:(NSNotification *)notification;
     - (void)handleDidMoveAnnotationNotification:(NSNotification *)notification;

     - (void)setNeedsDisplayInRect:(NSRect)rect ofPage:(PDFPage *)page;
     - (void)setNeedsDisplayForAnnotation:(PDFAnnotation *)annotation onPage:(PDFPage *)page;

     @end

     */
    
    /*
     #define EM_DASH_CHARACTER (unichar)0x2014
     NSString *SKSnapshotCurrentSetupKey = @"currentSetup";

     static char SKSnaphotWindowDefaultsObservationContext;
     */
    
    private let SMALL_DELAY =  0.1
    private let RESIZE_TIME_FACTOR = 0.6
    
    private let PAGE_KEY            = "page"
    private let RECT_KEY            = "rect"
    private let SCALEFACTOR_KEY     = "scaleFactor"
    private let AUTOFITS_KEY        = "autoFits"
    private let WINDOWFRAME_KEY     = "windowFrame"
    private let HASWINDOW_KEY       = "hasWindow"
    private let PAGELABEL_KEY       = "pageLabel"
    private let PAGEANDWINDOW_KEY   = "pageAndWindow"

    private let SKSnapshotWindowFrameAutosaveName = "SKSnapshotWindow"
    private let SKSnapshotViewChangedNotification = "SKSnapshotViewChangedNotification"
    
    private let SKSnapshotPageCellLabelKey = "label"
    private let SKSnapshotPageCellHasWindowKey = "hasWindow"
    
    deinit {
        KMPrint("KMSnapshotWindowController deinit.")
        
        NotificationCenter.default.removeObserver(self)
    }
    
    override var windowNibName: NSNib.Name? {
        return "SnapshotWindow"
    }

    override func windowDidLoad() {
        super.windowDidLoad()
    
//        if ([NSWindow instancesRespondToSelector:@selector(setTabbingMode:)])
//            [[self window] setTabbingMode:NSWindowTabbingModeDisallowed];
//        if ([NSWindow instancesRespondToSelector:@selector(toggleFullScreen:)])
//            [[self window] setCollectionBehavior:[[self window] collectionBehavior] | NSWindowCollectionBehaviorFullScreenAuxiliary];
//        if ([[self window] respondsToSelector:@selector(contentLayoutRect)]) {
//            [[self window] setStyleMask:[[self window] styleMask] | NSFullSizeContentViewWindowMask];
//            [pdfView setFrame:[[self window] contentLayoutRect]];
//        }
        if let data = self.window?.responds(to: NSSelectorFromString("contentLayoutRect")), data {
            self.window?.styleMask.insert(.fullSizeContentView)
            self.pdfView.frame = self.window?.contentLayoutRect ?? NSMakeRect(0, 0, 400, 400)
        }
        self._updateWindowLevel()
//        [[NSUserDefaultsController sharedUserDefaultsController] addObserver:self forKeys:[NSArray arrayWithObjects:SKSnapshotsOnTopKey, SKShouldAntiAliasKey, SKGreekingThresholdKey, SKBackgroundColorKey, SKPageBackgroundColorKey, nil] context:&SKSnaphotWindowDefaultsObservationContext];
        // the window is initialially exposed. The windowDidExpose notification is useless, it has nothing to do with showing the window
        self.hasWindow = true
    }
    
    /*
     + (NSSet *)keyPathsForValuesAffectingPageAndWindow {
         return [NSSet setWithObjects:PAGELABEL_KEY, HASWINDOW_KEY, nil];
     }

     // these should never be reached, but just to be sure

     - (void)windowDidDeminiaturize:(NSNotification *)notification {
         [self updateWindowLevel];
         [self setHasWindow:YES];
     }

     - (NSString *)windowTitleForDocumentDisplayName:(NSString *)displayName {
         return [NSString stringWithFormat:@"%@ %C %@", displayName, EM_DASH_CHARACTER, [NSString stringWithFormat:NSLocalizedString(@"Page %@", @""), [self pageLabel]]];
     }

     - (void)setNeedsDisplayInRect:(NSRect)rect ofPage:(PDFPage *)page {
         NSRect aRect = [pdfView convertRect:rect fromPage:page];
         CGFloat scale = [pdfView scaleFactor];
         CGFloat maxX = ceil(NSMaxX(aRect) + scale);
         CGFloat maxY = ceil(NSMaxY(aRect) + scale);
         CGFloat minX = floor(NSMinX(aRect) - scale);
         CGFloat minY = floor(NSMinY(aRect) - scale);
         
         aRect = NSIntersectionRect([pdfView bounds], NSMakeRect(minX, minY, maxX - minX, maxY - minY));
         if (NSIsEmptyRect(aRect) == NO)
             [pdfView setNeedsDisplayInRect:aRect];
     }

     - (void)setNeedsDisplayForAnnotation:(PDFAnnotation *)annotation onPage:(PDFPage *)page {
         [self setNeedsDisplayInRect:[annotation displayRect] ofPage:page];
     }

     - (void)redisplay {
         [pdfView requiresDisplay];
     }
*/


    @objc func handlePageChangedNotification(_ notification: NSNotification?) {
//         [self setPageLabel:[[pdfView currentPage] displayLabel]];
        let label = "\(self.pdfView.currentPage().pageIndex()+1)"
        self.pageLabel = label
        self.handlePDFViewFrameChangedNotification(nil)
     }
    
    @objc func handleDocumentDidUnlockNotification(_ notification: NSNotification) {
        let label = "\(self.pdfView.currentPage().pageIndex()+1)"
        self.pageLabel = label
        self.handlePDFViewFrameChangedNotification(nil)
    }
    
    @objc func handlePDFViewFrameChangedNotification(_ notification: NSNotification?) {
        if let _ = self.delegate?.snapshotControllerDidChange?(self) {
            let note = NSNotification(name: NSNotification.Name(rawValue: SKSnapshotViewChangedNotification), object: self)
            NotificationQueue.default.enqueue(note as Notification, postingStyle: .whenIdle, coalesceMask: .onName, forModes: nil)
        }
    }
    
    @objc func handleViewChangedNotification(_ notification: NSNotification) {
        self.updateString()
        self.delegate?.snapshotControllerDidChange?(self)
    }
    
    @objc func handleDidAddRemoveAnnotationNotification(_ notification: NSNotification) {
//        PDFAnnotation *annotation = [[notification userInfo] objectForKey:SKPDFViewAnnotationKey];
//        PDFPage *page = [[notification userInfo] objectForKey:SKPDFViewPageKey];
        guard let annotation = notification.userInfo?["annotation"] as? CPDFAnnotation else {
            return
        }
        guard let page = notification.userInfo?["page"] as? CPDFPage else {
            return
        }
        
//        if ([[page document] isEqual:[pdfView document]] && [self isPageVisible:page])
//            [self setNeedsDisplayForAnnotation:annotation onPage:page];
    }
    
    @objc func notifiyDidFinishSetup() {
        self.delegate?.snapshotControllerDidFinishSetup?(self)
    }
/*

     - (void)handleDidMoveAnnotationNotification:(NSNotification *)notification {
         PDFAnnotation *annotation = [[notification userInfo] objectForKey:SKPDFViewAnnotationKey];
         PDFPage *oldPage = [[notification userInfo] objectForKey:SKPDFViewOldPageKey];
         PDFPage *newPage = [[notification userInfo] objectForKey:SKPDFViewNewPageKey];
         if ([[newPage document] isEqual:[pdfView document]]) {
             if ([self isPageVisible:oldPage])
                 [self setNeedsDisplayForAnnotation:annotation onPage:oldPage];
             if ([self isPageVisible:newPage])
                 [self setNeedsDisplayForAnnotation:annotation onPage:newPage];
         }
     }


     - (void)setPdfDocument:(PDFDocument *)pdfDocument setup:(NSDictionary *)setup {
         [self setPdfDocument:pdfDocument
               goToPageNumber:[[setup objectForKey:PAGE_KEY] unsignedIntegerValue]
                         rect:NSRectFromString([setup objectForKey:RECT_KEY])
                  scaleFactor:[[setup objectForKey:SCALEFACTOR_KEY] doubleValue]
                     autoFits:[[setup objectForKey:AUTOFITS_KEY] boolValue]];
         
         [self setHasWindow:[[setup objectForKey:HASWINDOW_KEY] boolValue]];
         if ([setup objectForKey:WINDOWFRAME_KEY])
             [[self window] setFrame:NSRectFromString([setup objectForKey:WINDOWFRAME_KEY]) display:NO];
     }

     - (BOOL)isPageVisible:(PDFPage *)page {
         return [[page document] isEqual:[pdfView document]] && NSLocationInRange([page pageIndex], [pdfView displayedPageIndexRange]);
     }

     #pragma mark Acessors

     - (NSRect)bounds {
         NSView *clipView = [[[pdfView documentView] enclosingScrollView] contentView];
         return [pdfView convertRect:[pdfView convertRect:[clipView bounds] fromView:clipView] toPage:[pdfView currentPage]];
     }

     - (NSUInteger)pageIndex {
         return [[pdfView currentPage] pageIndex];
     }
*/
    
    func pageAndWindow() -> NSDictionary {
        return [SKSnapshotPageCellLabelKey : self.pageLabel, SKSnapshotPageCellHasWindowKey : NSNumber(booleanLiteral: self.hasWindow)]
    }

    func setForceOnTop(_ flag: Bool) {
        self.forceOnTop = flag
        if let data = self.window?.isVisible, data {
            self._updateWindowLevel()
        }
    }
/*

     - (NSDictionary *)currentSetup {
         NSView *clipView = [[[pdfView documentView] enclosingScrollView] contentView];
         NSRect rect = [pdfView convertRect:[pdfView convertRect:[clipView bounds] fromView:clipView] toPage:[pdfView currentPage]];
         BOOL autoFits = [pdfView autoFits];
         return [NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithUnsignedInteger:[self pageIndex]], PAGE_KEY, NSStringFromRect(rect), RECT_KEY, [NSNumber numberWithDouble:[pdfView scaleFactor]], SCALEFACTOR_KEY, [NSNumber numberWithBool:autoFits], AUTOFITS_KEY, [NSNumber numberWithBool:[[self window] isVisible]], HASWINDOW_KEY, NSStringFromRect([[self window] frame]), WINDOWFRAME_KEY, nil];
     }

     #pragma mark Actions

     - (IBAction)doGoToNextPage:(id)sender {
         [pdfView goToNextPage:sender];
     }

     - (IBAction)doGoToPreviousPage:(id)sender {
         [pdfView goToPreviousPage:sender];
     }

     - (IBAction)doGoToFirstPage:(id)sender {
         [pdfView goToFirstPage:sender];
     }

     - (IBAction)doGoToLastPage:(id)sender {
         [pdfView goToLastPage:sender];
     }

     - (IBAction)doGoBack:(id)sender {
         [pdfView goBack:sender];
     }

     - (IBAction)doGoForward:(id)sender {
         [pdfView goForward:sender];
     }

     - (IBAction)doZoomIn:(id)sender {
         [pdfView zoomIn:sender];
     }

     - (IBAction)doZoomOut:(id)sender {
         [pdfView zoomOut:sender];
     }

     - (IBAction)doZoomToPhysicalSize:(id)sender {
         [pdfView setPhysicalScaleFactor:1.0];
     }

     - (IBAction)doZoomToActualSize:(id)sender {
         [pdfView setScaleFactor:1.0];
     }

     - (IBAction)toggleAutoScale:(id)sender {
         [pdfView setAutoFits:[pdfView autoFits] == NO];
     }

     - (BOOL)validateMenuItem:(NSMenuItem *)menuItem {
         SEL action = [menuItem action];
         if (action == @selector(doGoToNextPage:)) {
             return [pdfView canGoToNextPage];
         } else if (action == @selector(doGoToPreviousPage:)) {
             return [pdfView canGoToPreviousPage];
         } else if (action == @selector(doGoToFirstPage:)) {
             return [pdfView canGoToFirstPage];
         } else if (action == @selector(doGoToLastPage:)) {
             return [pdfView canGoToLastPage];
         } else if (action == @selector(doGoBack:)) {
             return [pdfView canGoBack];
         } else if (action == @selector(doGoForward:)) {
             return [pdfView canGoForward];
         } else if (action == @selector(doZoomIn:)) {
             return [pdfView canZoomIn];
         } else if (action == @selector(doZoomOut:)) {
             return [pdfView canZoomOut];
         } else if (action == @selector(doZoomToActualSize:)) {
             return fabs([pdfView scaleFactor] - 1.0 ) > 0.01;
         } else if (action == @selector(doZoomToPhysicalSize:)) {
             return fabs([pdfView physicalScaleFactor] - 1.0 ) > 0.01;
         } else if (action == @selector(toggleAutoScale:)) {
             [menuItem setState:[pdfView autoFits] ? NSOnState : NSOffState];
             return YES;
         }
         return YES;
     }

 */
    // MARK: - Thumbnails

    func thumbnailWithSize(_ size: CGFloat) -> NSImage? {
        let clipView = self.pdfView.documentView().contentView
        var bounds = self.pdfView.convert(clipView.bounds, from: clipView)
         if (CGRectEqualToRect(CGRectZero, bounds) || CGRectIsNull(bounds)) {
             return nil
         }
        let imageRep = self.pdfView.bitmapImageRepForCachingDisplay(in: bounds)
        var transform: NSAffineTransform?
         var thumbnailSize = bounds.size
        var shadowBlurRadius: CGFloat = 0.0
        var shadowOffset: CGFloat = 0.0
        var image: NSImage?
        if let data = imageRep {
            self.pdfView.cacheDisplay(in: bounds, to: data)
        }
         
         bounds.origin = NSZeroPoint
         
         if (size > 0.0) {
             shadowBlurRadius = round(size / 32.0)
             shadowOffset = -ceil(shadowBlurRadius * 0.75)
             if (NSHeight(bounds) > NSWidth(bounds)) {
                 thumbnailSize = NSMakeSize(round((size - 2.0 * shadowBlurRadius) * NSWidth(bounds) / NSHeight(bounds) + 2.0 * shadowBlurRadius), size);
             } else {
                 thumbnailSize = NSMakeSize(size, round((size - 2.0 * shadowBlurRadius) * NSHeight(bounds) / NSWidth(bounds) + 2.0 * shadowBlurRadius));
             }
             transform = NSAffineTransform()
             transform?.translateX(by: shadowBlurRadius, yBy: shadowBlurRadius - shadowOffset)
             transform?.scaleX(by: (thumbnailSize.width - 2.0 * shadowBlurRadius) / NSWidth(bounds), yBy: (thumbnailSize.height - 2.0 * shadowBlurRadius) / NSHeight(bounds))
         }
         
         if (CGSizeEqualToSize(CGSizeZero, thumbnailSize)) {
             return nil
         }
         image = NSImage(size: thumbnailSize)
         
         if (CGSizeEqualToSize(CGSizeZero, image!.size)) {
             return nil
         }
        image?.lockFocus()
        NSGraphicsContext.current?.imageInterpolation = .high
        transform?.concat()
        NSGraphicsContext.saveGraphicsState()
//         [[PDFView defaultPageBackgroundColor] set];
        if (shadowBlurRadius > 0.0) {
//            [NSShadow setShadowWithColor:[NSColor colorWithCalibratedWhite:0.0 alpha:0.5] blurRadius:shadowBlurRadius yOffset:shadowOffset];
        }
        __NSRectFill(bounds)
        NSGraphicsContext.current?.imageInterpolation = .default
        NSGraphicsContext.restoreGraphicsState()
        imageRep?.draw(in: bounds)
        image?.unlockFocus()
         
         return image
     }
    /*

     - (NSAttributedString *)thumbnailAttachmentWithSize:(CGFloat)size {
         NSImage *image = [self thumbnailWithSize:size];
         
         NSFileWrapper *wrapper = [[NSFileWrapper alloc] initRegularFileWithContents:[image TIFFRepresentation]];
         NSString *filename = [NSString stringWithFormat:@"snapshot_page_%lu.tiff",(unsigned long)( [self pageIndex] + 1)];
         [wrapper setFilename:filename];
         [wrapper setPreferredFilename:filename];

         NSTextAttachment *attachment = [[NSTextAttachment alloc] initWithFileWrapper:wrapper];
         [wrapper release];
         NSAttributedString *attrString = [NSAttributedString attributedStringWithAttachment:attachment];
         [attachment release];
         
         return attrString;
     }

     - (NSAttributedString *)thumbnailAttachment {
         return [self thumbnailAttachmentWithSize:0.0];
     }

     - (NSAttributedString *)thumbnail512Attachment {
         return [self thumbnailAttachmentWithSize:512.0];
     }

     - (NSAttributedString *)thumbnail256Attachment {
         return [self thumbnailAttachmentWithSize:256.0];
     }

     - (NSAttributedString *)thumbnail128Attachment {
         return [self thumbnailAttachmentWithSize:128.0];
     }

     - (NSAttributedString *)thumbnail64Attachment {
         return [self thumbnailAttachmentWithSize:64.0];
     }

     - (NSAttributedString *)thumbnail32Attachment {
         return [self thumbnailAttachmentWithSize:32.0];
     }

 */
    // MARK: - Miniaturize / Deminiaturize

    func miniaturizedRectForDockingRect(_ dockRect: NSRect) -> NSRect {
        let clipView = self.pdfView.documentView().contentView
        let sourceRect = clipView.convert(clipView.bounds, to: nil)
        var targetRect: NSRect = .zero
        let windowSize = self.window?.frame.size ?? .zero
        let thumbSize = self.thumbnail?.size ?? .zero
        var thumbRatio: CGFloat = 0
        if thumbSize.width > 0 {
            thumbRatio = thumbSize.height / thumbSize.width
        }
        var dockRatio: CGFloat = 0
        if NSWidth(dockRect) > 0 {
            dockRatio = NSHeight(dockRect) / NSWidth(dockRect)
        }
        var scaleFactor: CGFloat = 0
         var shadowRadius = round(fmax(thumbSize.width, thumbSize.height) / 32.0)
         var shadowOffset = ceil(0.75 * shadowRadius)
         
         if (thumbRatio > dockRatio) {
             targetRect = NSInsetRect(dockRect, 0.5 * NSWidth(dockRect) * (1.0 - dockRatio / thumbRatio), 0.0)
             scaleFactor = NSHeight(targetRect) / thumbSize.height
         } else {
             targetRect = NSInsetRect(dockRect, 0.0, 0.5 * NSHeight(dockRect) * (1.0 - thumbRatio / dockRatio))
             scaleFactor = NSWidth(targetRect) / thumbSize.width
         }
         shadowRadius *= scaleFactor
         shadowOffset *= scaleFactor
         targetRect = NSOffsetRect(NSInsetRect(targetRect, shadowRadius, shadowRadius), 0.0, shadowOffset)
        if thumbRatio > dockRatio {
            if NSHeight(sourceRect) != 0 {
                scaleFactor = NSHeight(targetRect) / NSHeight(sourceRect)
            }
        } else {
            if NSWidth(sourceRect) != 0 {
                scaleFactor = NSWidth(targetRect) / NSWidth(sourceRect)
            }
        }
         
         return NSMakeRect(NSMinX(targetRect) - scaleFactor * NSMinX(sourceRect), NSMinY(targetRect) - scaleFactor * NSMinY(sourceRect), scaleFactor * windowSize.width, scaleFactor * windowSize.height);
     }

    func miniaturizeWindowFromRect(_ startRect: NSRect, toRect endRect: NSRect) {
        if (self.windowImage == nil) {
            self.windowImage = (self.window as? KMSnapshotWindow)?.windowImage
        }
         
        let miniaturizeWindow = KMAnimatedBorderlessWindow(contentRect: startRect)
        miniaturizeWindow.level = .floating
        miniaturizeWindow.backgroundImage = self.windowImage
        miniaturizeWindow.orderFront(nil)
        self.animating = true
         
        NSAnimationContext.runAnimationGroup { context in
            context.duration = RESIZE_TIME_FACTOR * miniaturizeWindow.animationResizeTime(endRect)
            miniaturizeWindow.animator().setFrame(endRect, display: true)
        } completionHandler: {
            if self.hasWindow {
                if let data = self.window?.responds(to: NSSelectorFromString("setAnimationBehavior:")), data {
                    self.window?.animationBehavior = .none
                }
                self.window?.orderFront(nil)
                self._updateWindowLevel()
                if let data = self.window?.responds(to: NSSelectorFromString("setAnimationBehavior:")), data {
                    self.window?.animationBehavior = .default
                }
            }
            miniaturizeWindow.orderOut(nil)
            self.animating = false
        }
     }
    
    func miniaturize() {
        if (self.animating) {
            return
        }
        if let dockRect = self.delegate?.snapshotController?(self, miniaturizedRect: true) {
            let startRect = self.window?.frame ?? .zero
            let endRect = self.miniaturizedRectForDockingRect(dockRect)
             
            self.miniaturizeWindowFromRect(startRect, toRect: endRect)
             
            if let data = self.window?.responds(to: NSSelectorFromString("setAnimationBehavior:")), data {
                self.window?.animationBehavior = .none
            }
         }
        self.window?.orderOut(nil)
        
        if let data = self.window?.responds(to: NSSelectorFromString("setAnimationBehavior:")), data {
            self.window?.animationBehavior = .default
        }
        self.hasWindow = false
     }
    
    func deminiaturize() {
        if (self.animating) {
            return
        }
        if let dockRect = self.delegate?.snapshotController?(self, miniaturizedRect: false) {
            let endRect = self.window?.frame ?? .zero
            let startRect = self.miniaturizedRectForDockingRect(dockRect)
            
            self.miniaturizeWindowFromRect(startRect, toRect: endRect)
//            SKDESTROY(windowImage);
        } else {
            self.showWindow(self)
        }
        self.hasWindow = true
    }
/*
     #pragma mark KVO

     - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
         if (context == &SKSnaphotWindowDefaultsObservationContext) {
             NSString *key = [keyPath substringFromIndex:7];
             if ([key isEqualToString:SKSnapshotsOnTopKey]) {
                 if ([[self window] isVisible])
                     [self updateWindowLevel];
             } else if ([key isEqualToString:SKShouldAntiAliasKey]) {
                 [pdfView setShouldAntiAlias:[[NSUserDefaults standardUserDefaults] boolForKey:SKShouldAntiAliasKey]];
                 [pdfView applyDefaultInterpolationQuality];
             } else if ([key isEqualToString:SKGreekingThresholdKey]) {
                 [pdfView setGreekingThreshold:[[NSUserDefaults standardUserDefaults] floatForKey:SKGreekingThresholdKey]];
             } else if ([key isEqualToString:SKBackgroundColorKey]) {
                 [pdfView setBackgroundColor:[[NSUserDefaults standardUserDefaults] colorForKey:SKBackgroundColorKey]];
             } else if ([key isEqualToString:SKPageBackgroundColorKey]) {
                 [pdfView applyDefaultPageBackgroundColor];
             }
         } else {
             [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
         }
     }
     
     */
    
    func updateString() {
        var mutableString = ""
        let clipView = self.pdfView.documentView().contentView
        let rect = clipView.convert(clipView.visibleRect, to: self.pdfView)
        
        for page in self.pdfView.displayedPages() {
            guard let _page = page as? CPDFPage else {
                continue
            }
            let frame = self.pdfView.convert(rect, to: _page)
            let sel = _page.selection(for: frame)
            if let data = sel?.hasCharacters(), data {
                if mutableString.isEmpty == false {
                    mutableString.append("\n")
                }
                mutableString.append(sel?.string() ?? "")
            }
        }
        self.string = mutableString
    }
    
    @objc func goToRect(_ rectValue: NSValue) {
        self.pdfView.go(to: rectValue.rectValue, on: self.pdfView.currentPage())
        self.pdfView.resetHistory()
        
        self.updateString()

        self.window?.makeFirstResponder(self.pdfView)
        self.handlePageChangedNotification(nil)
//
//        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handlePageChangedNotification:)
//                                                     name:PDFViewPageChangedNotification object:pdfView];
//        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleDocumentDidUnlockNotification:)
//                                                     name:PDFDocumentDidUnlockNotification object:[pdfView document]];
//
//        NSView *clipView = [[[pdfView documentView] enclosingScrollView] contentView];
//        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handlePDFViewFrameChangedNotification:)
//                                                     name:NSViewFrameDidChangeNotification object:clipView];
//        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handlePDFViewFrameChangedNotification:)
//                                                     name:NSViewBoundsDidChangeNotification object:clipView];
//        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleViewChangedNotification:)
//                                                     name:SKSnapshotViewChangedNotification object:self];
//        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleDidAddRemoveAnnotationNotification:)
//                                                     name:SKPDFViewDidAddAnnotationNotification object:nil];
//        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleDidAddRemoveAnnotationNotification:)
//                                                     name:SKPDFViewDidRemoveAnnotationNotification object:nil];
//        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleDidMoveAnnotationNotification:)
//                                                     name:SKPDFViewDidMoveAnnotationNotification object:nil];
        self.perform(#selector(notifiyDidFinishSetup), with: nil, afterDelay: SMALL_DELAY)
//
        if self.hasWindow {
            self.showWindow(nil)
        }
    }
    
    func setPdfDocument(_ pdfDocument: CPDFDocument, goToPageNumber pageNum: Int, rect: NSRect, scaleFactor factor: CGFloat, autoFits: Bool) {
        let window = self.window
        
        self.pdfView.scaleFactor = factor
        self.pdfView.autoScales = false
        self.pdfView.displaysPageBreaks = false
        self.pdfView.displayBox = .cropBox
//        [pdfView setShouldAntiAlias:[[NSUserDefaults standardUserDefaults] floatForKey:]];
        self.pdfView.setShouldAntiAlias(UserDefaults.standard.bool(forKey: SKShouldAntiAliasKey))
        self.pdfView.setGreekingThreshold(UserDefaults.standard.float(forKey: SKGreekingThresholdKey).cgFloat)
        self.pdfView.backgroundColor = UserDefaults.standard.color(forKey: SKBackgroundColorKey)
//        [pdfView applyDefaultPageBackgroundColor];
//        [pdfView applyDefaultInterpolationQuality];
        self.pdfView.document = pdfDocument
        
//        [self setWindowFrameAutosaveNameOrCascade:SKSnapshotWindowFrameAutosaveName];
        
        if let controlView = self.pdfView.scalePopUpButton {
            var controlFrame: NSRect = .zero
            var frame: NSRect = .zero
            NSDivideRect(self.pdfView.frame, &controlFrame, &frame, NSHeight(controlView.frame), .minY)
            //        NSDivideRect([pdfView frame], &controlFrame, &frame, NSHeight([controlView frame]), NSMinYEdge);
            controlFrame.size.width = NSWidth(controlView.frame)
            controlView.frame = controlFrame
            controlView.autoresizingMask = [.maxXMargin, .maxYMargin]
            window?.contentView?.addSubview(controlView)
            self.pdfView.frame = frame
            window?.backgroundColor = NSColor(calibratedWhite: 0.97, alpha: 1)
            
            let page = pdfDocument.page(at: UInt(pageNum))
            frame = self.pdfView.convert(rect, from: page)
            var view: NSView?
            frame = self.pdfView.convert(frame, to: view)
            frame.size.height += NSHeight(controlFrame)
            
//                    frame = [NSWindow frameRectForContentRect:frame styleMask:[window styleMask] & ~NSWindowStyleMaskFullSizeContentView];
            var styleMask = window?.styleMask
            styleMask?.remove(.fullSizeContentView)

            frame = NSWindow.frameRect(forContentRect: frame, styleMask: styleMask!)
            frame.origin.x = NSMinX(window!.frame)
            frame.origin.y = NSMaxY(window!.frame) - NSHeight(frame)
            self.window?.setFrame(frame, display: false, animate: false)
        }
        
        self.pdfView.go(toPageIndex: pageNum, animated: false)
        
        if (autoFits) {
            self.pdfView.autoFits = autoFits
        }
        
        // Delayed to allow PDFView to finish its bookkeeping
        // fixes bug of apparently ignoring the point but getting the page right.
        self.perform(#selector(goToRect), with: NSValue(rect: rect), afterDelay: SMALL_DELAY)
    }

}

// MARK: - Private Methods

extension KMSnapshotWindowController {
    private func _updateWindowLevel() {
        
        let onTop = self.forceOnTop || UserDefaults.standard.bool(forKey: SKSnapshotsOnTopKey)
        self.window?.level = onTop ? .floating : .normal
        self.window?.hidesOnDeactivate = onTop
    }
}

extension KMSnapshotWindowController: NSWindowDelegate {
    
    func windowWillClose(_ notification: Notification) {
//        @try { [[NSUserDefaultsController sharedUserDefaultsController] removeObserver:self forKeys:[NSArray arrayWithObjects:SKSnapshotsOnTopKey, SKShouldAntiAliasKey, SKGreekingThresholdKey, SKBackgroundColorKey, SKPageBackgroundColorKey, nil]]; }
//        @catch (id e) {}
        self.delegate?.snapshotControllerWillClose?(self)
            
        self.delegate = nil
        // Yosemite and El Capitan have a retain cycle when we leave the PDFView with a document
//        if (RUNNING_AFTER(10_9) && RUNNING_BEFORE(10_12))
        self.pdfView.document = nil
    }
    
    func windowDidMiniaturize(_ notification: Notification) {
        self.window?.orderOut(nil)
        self.hasWindow = false
    }
}