bug fix

Author: rustamburger-mrustaa

Example/ButtonClickStyle.xcodeproj/project.pbxproj

@@ -0,0 +1,92 @@
+//
+//  ColletionAdapterCell.swift
+//  PatternsSwift
+//
+//  Created by mrustaa on 01/05/2020.
+//  Copyright © 2020 mrustaa. All rights reserved.
+//
+
+import UIKit
+
+class CollectionAdapterCell: UICollectionViewCell {
+    
+    open var didScrollCallback: (() -> ())? = nil
+  
+    @IBInspectable var hideAnimation: Bool = false
+    var selectedView: UIView?
+    
+    public var cellData: CollectionAdapterCellData?
+    
+    open func fill(data: Any?) {
+        
+    }
+    
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setupCommonProperties()
+    }
+    
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setupCommonProperties()
+    }
+    
+    private func setupCommonProperties() {
+        
+    }
+    
+    let selAlpha: CGFloat = 0.2
+    
+    override var isSelected: Bool {
+        set {
+            super.isSelected = newValue
+            if hideAnimation {
+                if newValue {
+                  alpha = 0.5
+                    UIView.animate(withDuration: 0.45, animations: {
+                        self.alpha = 1
+                    })
+                } else {
+                    self.alpha = 1
+                }
+            } else {
+              guard let selectedView = selectedView else { return }
+              if newValue {
+                  selectedView.alpha = selAlpha
+                  UIView.animate(withDuration: 0.45, animations: {
+                      selectedView.alpha = 0.0
+                  })
+              } else {
+                  selectedView.alpha = 0.0
+              }
+            }
+        }
+        get {
+            return super.isSelected
+        }
+    }
+    
+    override var isHighlighted: Bool {
+        set {
+            super.isHighlighted = newValue
+            if hideAnimation {
+              UIView.animate(withDuration: newValue ? 0.1 : 0.45, animations: {
+                self.alpha = (newValue ? 0.0 : 1.0)
+              })
+            } else {
+                guard let selectedView = selectedView else { return }
+                if newValue {
+                    UIView.animate(withDuration: 0.1, animations: {
+                        selectedView.alpha = self.selAlpha
+                    })
+                } else {
+                    UIView.animate(withDuration: 0.45, animations: {
+                        selectedView.alpha = 0.0
+                    })
+                }
+            }
+        }
+       get { super.isHighlighted }
+    }
+    
+}

Example/ButtonClickStyle/AdapterView/CollectionAdapterView/Cell/CollectionAdapterCell.swift

@@ -0,0 +1,16 @@
+//
+//  ColletionAdapterCellData.swift
+//  PatternsSwift
+//
+//  Created by mrustaa on 01/05/2020.
+//  Copyright © 2020 mrustaa. All rights reserved.
+//
+
+import UIKit
+
+class CollectionAdapterCellData: NSObject {
+    
+    open func size() -> CGSize {
+        return .zero
+    }
+}

Example/ButtonClickStyle/AdapterView/CollectionAdapterView/Cell/CollectionAdapterCellData.swift

@@ -0,0 +1,29 @@
+//
+//  ColletionAdapterItem.swift
+//  PatternsSwift
+//
+//  Created by mrustaa on 01/05/2020.
+//  Copyright © 2020 mrustaa. All rights reserved.
+//
+
+import UIKit
+
+class CollectionAdapterItem: NSObject {
+    
+    public let cellClass: AnyClass
+    public let cellData: CollectionAdapterCellData?
+    
+    public var cellReuseIdentifier: String {
+        return String(describing: cellClass)
+    }
+    
+    init(cellClass: AnyClass, cellData: CollectionAdapterCellData? = nil) {
+        self.cellClass = cellClass
+        self.cellData = cellData
+    }
+    
+    public func size() -> CGSize {
+        return cellData?.size() ?? .zero
+    }
+    
+}

Example/ButtonClickStyle/AdapterView/CollectionAdapterView/Cell/CollectionAdapterItem.swift

@@ -0,0 +1,15 @@
+//
+//  CollectionAdapterTypes.swift
+//  PatternsSwift
+//
+//  Created by mrustaa on 01/05/2020.
+//  Copyright © 2020 mrustaa. All rights reserved.
+//
+
+import UIKit
+
+typealias CollectionAdapterCountCallback = () -> Int
+typealias CollectionAdapterCellIndexCallback = (_ index: Int) -> UICollectionViewCell
+typealias CollectionAdapterSizeIndexCallback = (_ index: Int) -> CGSize
+typealias CollectionAdapterSelectIndexCallback = (_ index: Int) -> ()
+typealias CollectionAdapterWillEndDraggingCallback = (_ velocity: CGPoint, _ targetContentOffset: UnsafeMutablePointer<CGPoint>) -> ()

Example/ButtonClickStyle/AdapterView/CollectionAdapterView/CollectionAdapterTypes.swift

@@ -0,0 +1,131 @@
+//
+//  CollectionAdapterView.swift
+//  PatternsSwift
+//
+//  Created by mrustaa on 01/05/2020.
+//  Copyright © 2020 mrustaa. All rights reserved.
+//
+
+import UIKit
+
+class CollectionAdapterView: UICollectionView {
+    
+    var countCallback: CollectionAdapterCountCallback?
+    var cellIndexCallback: CollectionAdapterCellIndexCallback?
+    var sizeIndexCallback: CollectionAdapterSizeIndexCallback?
+    var selectIndexCallback: CollectionAdapterSelectIndexCallback?
+    var didScrollCallback: TableAdapterDidScrollCallback?
+    var willEndDraggingCallback: CollectionAdapterWillEndDraggingCallback?
+
+  
+    var items: [CollectionAdapterItem] = []
+    
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        update()
+    }
+    
+    override init(frame: CGRect, collectionViewLayout layout: UICollectionViewLayout) {
+        super.init(frame: frame, collectionViewLayout: layout)
+        update()
+    }
+    
+    func update() {
+        delegate = self
+        dataSource = self
+    }
+    
+    
+    public func set(items: [CollectionAdapterItem]) {
+        items.forEach {
+            registerNibIfNeeded(for: $0)
+        }
+        self.items = items
+        reloadData()
+    }
+    
+    public func registerNibIfNeeded(for item: CollectionAdapterItem) {
+        let nib = UINib(nibName: item.cellReuseIdentifier, bundle: nil)
+        register(nib, forCellWithReuseIdentifier: item.cellReuseIdentifier)
+    }
+    
+    public func clear() {
+        items = []
+        reloadData()
+    }
+    
+    private func cellAt(_ indexPath: IndexPath) -> CollectionAdapterCell? {
+        let item = items[indexPath.row]
+        let cellIdentifier = item.cellReuseIdentifier
+        let cell = dequeueReusableCell(withReuseIdentifier: cellIdentifier, for: indexPath) as? CollectionAdapterCell
+        cell?.cellData = item.cellData
+        return cell
+    }
+  
+  public func cell<T>(index: Int,
+                           completion: @escaping(T)->() ) {
+    guard let cell = cellForItem(at: .init(row: index, section: 0)) as? T else {
+      return
+    }
+    completion(cell)
+  }
+    
+}
+
+extension CollectionAdapterView: UICollectionViewDelegate {
+    
+    func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
+      selectIndexCallback?(indexPath.row)
+    }
+}
+
+extension CollectionAdapterView: UICollectionViewDataSource {
+    
+    func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
+        if !items.isEmpty {
+            return items.count
+        }
+        if let countCallback = countCallback {
+            return countCallback()
+        }
+        return 0
+    }
+    
+    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
+        if !items.isEmpty {
+            let item = items[indexPath.row]
+            let cell = cellAt(indexPath)
+            cell?.fill(data: item.cellData)
+            return cell ?? UICollectionViewCell()
+        }
+        if let cellIndexCallback = cellIndexCallback {
+            return cellIndexCallback(indexPath.row)
+        }
+        return UICollectionViewCell()
+    }
+}
+
+extension CollectionAdapterView: UICollectionViewDelegateFlowLayout {
+    
+    public func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
+        if !items.isEmpty {
+            let item = items[indexPath.row]
+            return item.size()
+        }
+        if let sizeIndexCallback = sizeIndexCallback {
+            return sizeIndexCallback(indexPath.row)
+        }
+        return .zero
+    }
+}
+
+extension CollectionAdapterView: UIScrollViewDelegate {
+  public func scrollViewDidScroll(_ scrollView: UIScrollView) {
+    didScrollCallback?()
+  }
+  
+  public func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {
+    willEndDraggingCallback?(velocity, targetContentOffset)
+  }
+}
+

Example/ButtonClickStyle/AdapterView/CollectionAdapterView/CollectionAdapterView.swift

@@ -0,0 +1,110 @@
+// Copyright (c) 2017 Cœur
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import UIKit
+
+/**
+ *  Simple UICollectionViewFlowLayout that centers the cells rather than justify them
+ *
+ *  Based on https://github.com/Coeur/UICollectionViewLeftAlignedLayout
+ */
+open class UICollectionViewCenteredFlowLayout: UICollectionViewFlowLayout {
+    open override func layoutAttributesForElements(in rect: CGRect) -> [UICollectionViewLayoutAttributes]? {
+        guard let layoutAttributesForElements = super.layoutAttributesForElements(in: rect) else {
+            return nil
+        }
+        guard let collectionView = collectionView else {
+            return layoutAttributesForElements
+        }
+        // we group copies of the elements from the same row/column
+        var representedElements: [UICollectionViewLayoutAttributes] = []
+        var cells: [[UICollectionViewLayoutAttributes]] = [[]]
+        var previousFrame: CGRect?
+        if scrollDirection == .vertical {
+            for layoutAttributes in layoutAttributesForElements {
+                guard layoutAttributes.representedElementKind == nil else {
+                    representedElements.append(layoutAttributes)
+                    continue
+                }
+                // copying is required to avoid "UICollectionViewFlowLayout cache mismatched frame"
+                let currentItemAttributes = layoutAttributes.copy() as! UICollectionViewLayoutAttributes
+                // if the current frame, once stretched to the full row doesn't intersect the previous frame then they are on different rows
+                if previousFrame != nil && !currentItemAttributes.frame.intersects(CGRect(x: -.greatestFiniteMagnitude, y: previousFrame!.origin.y, width: .infinity, height: previousFrame!.size.height)) {
+                    cells.append([])
+                }
+                cells[cells.endIndex - 1].append(currentItemAttributes)
+                previousFrame = currentItemAttributes.frame
+            }
+            // we reposition all elements
+            return representedElements + cells.flatMap { group -> [UICollectionViewLayoutAttributes] in
+                guard let section = group.first?.indexPath.section else {
+                    return group
+                }
+                let evaluatedSectionInset = evaluatedSectionInsetForSection(at: section)
+                let evaluatedMinimumInteritemSpacing = evaluatedMinimumInteritemSpacingForSection(at: section)
+                var origin = (collectionView.bounds.width + evaluatedSectionInset.left - evaluatedSectionInset.right - group.reduce(0, { $0 + $1.frame.size.width }) - CGFloat(group.count - 1) * evaluatedMinimumInteritemSpacing) / 2
+                // we reposition each element of a group
+                return group.map {
+                    $0.frame.origin.x = origin
+                    origin += $0.frame.size.width + evaluatedMinimumInteritemSpacing
+                    return $0
+                }
+            }
+        } else {
+            for layoutAttributes in layoutAttributesForElements {
+                guard layoutAttributes.representedElementKind == nil else {
+                    representedElements.append(layoutAttributes)
+                    continue
+                }
+                // copying is required to avoid "UICollectionViewFlowLayout cache mismatched frame"
+                let currentItemAttributes = layoutAttributes.copy() as! UICollectionViewLayoutAttributes
+                // if the current frame, once stretched to the full column doesn't intersect the previous frame then they are on different columns
+                if previousFrame != nil && !currentItemAttributes.frame.intersects(CGRect(x: previousFrame!.origin.x, y: -.greatestFiniteMagnitude, width: previousFrame!.size.width, height: .infinity)) {
+                    cells.append([])
+                }
+                cells[cells.endIndex - 1].append(currentItemAttributes)
+                previousFrame = currentItemAttributes.frame
+            }
+            // we reposition all elements
+            return representedElements + cells.flatMap { group -> [UICollectionViewLayoutAttributes] in
+                guard let section = group.first?.indexPath.section else {
+                    return group
+                }
+                let evaluatedSectionInset = evaluatedSectionInsetForSection(at: section)
+                let evaluatedMinimumInteritemSpacing = evaluatedMinimumInteritemSpacingForSection(at: section)
+                var origin = (collectionView.bounds.height + evaluatedSectionInset.top - evaluatedSectionInset.bottom - group.reduce(0, { $0 + $1.frame.size.height }) - CGFloat(group.count - 1) * evaluatedMinimumInteritemSpacing) / 2
+                // we reposition each element of a group
+                return group.map {
+                    $0.frame.origin.y = origin
+                    origin += $0.frame.size.height + evaluatedMinimumInteritemSpacing
+                    return $0
+                }
+            }
+        }
+    }
+}
+
+extension UICollectionViewFlowLayout {
+    internal func evaluatedSectionInsetForSection(at section: Int) -> UIEdgeInsets {
+        return (collectionView?.delegate as? UICollectionViewDelegateFlowLayout)?.collectionView?(collectionView!, layout: self, insetForSectionAt: section) ?? sectionInset
+    }
+    internal func evaluatedMinimumInteritemSpacingForSection(at section: Int) -> CGFloat {
+        return (collectionView?.delegate as? UICollectionViewDelegateFlowLayout)?.collectionView?(collectionView!, layout: self, minimumInteritemSpacingForSectionAt: section) ?? minimumInteritemSpacing
+    }
+}