uicore-ts 1.0.1

package/scripts/UILinkButton.ts

@@ -0,0 +1,238 @@
+import { UIButton, UIButtonColorSpecifier } from "./UIButton"
+import { UILink } from "./UILink"
+
+
+
+
+export class UILinkButton extends UILink {
+    
+    
+    button: UIButton
+    
+    //link = new UILink(this.elementID + "Link");
+    
+    
+    
+    
+    
+    constructor(elementID: string, elementType?: string, titleType?: string) {
+        
+        super(elementID, { "elementType": elementType, "titleType": titleType })
+        
+        this._class = UILinkButton
+        this.superclass = UILink
+        
+        
+        this.button.addTargetForControlEvents([
+            UIButton.controlEvent.EnterDown, UIButton.controlEvent.PointerUpInside
+        ], function (this: UILinkButton, sender: UIButton, event: Event) {
+    
+            const asd = 1
+    
+            window.location = this.target as any
+            
+            
+        }.bind(this))
+        
+        // this.link.hidden = YES;
+        
+        // this.addSubview(this.link);
+        
+        
+    }
+    
+    
+    
+    
+    
+    initView(elementID, viewHTMLElement, initViewData: { titleType: string, elementType: string }) {
+        
+        super.initView(elementID, viewHTMLElement, initViewData)
+        
+        this.class.superclass = UILink
+        
+        // Instance variables
+        
+        this.button = new UIButton(this.elementID + "Button", initViewData.elementType, initViewData.titleType)
+        
+        this.addSubview(this.button)
+        
+        this.style.position = "absolute"
+        
+        
+        
+        
+        
+    }
+    
+    
+    
+    
+    
+    get titleLabel() {
+        
+        return this.button.titleLabel
+        
+    }
+    
+    get imageView() {
+        
+        return this.button.imageView
+        
+    }
+    
+    
+    set colors(colors: UIButtonColorSpecifier) {
+        
+        this.button.colors = colors
+        
+    }
+    
+    
+    get colors() {
+        
+        return this.button.colors
+        
+    }
+    
+    
+    
+    
+    
+    get viewHTMLElement() {
+        
+        // @ts-ignore
+        return super.viewHTMLElement as HTMLLinkElement
+        
+    }
+    
+    
+    set target(target: string) {
+        
+        this.viewHTMLElement.setAttribute("href", target)
+        
+    }
+    
+    get target() {
+    
+        const result = this.viewHTMLElement.getAttribute("href")
+    
+        return result
+        
+    }
+    
+    
+    
+    
+    
+    layoutSubviews() {
+        
+        super.layoutSubviews()
+    
+        const bounds = this.bounds
+    
+        this.button.frame = bounds
+        
+        this.button.layoutSubviews()
+        
+        
+    }
+    
+    
+    
+    
+    
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/scripts/UINativeScrollView.ts

@@ -0,0 +1,254 @@
+import { nil } from "./UIObject"
+import { UIPoint } from "./UIPoint"
+import { UIView } from "./UIView"
+
+
+
+
+
+export class UINativeScrollView extends UIView {
+    
+    
+    animationDuration = 0
+    
+    constructor(elementID, viewHTMLElement?) {
+        
+        super(elementID, viewHTMLElement)
+        
+        this._class = UINativeScrollView
+        this.superclass = UIView
+        
+        
+        this.style.cssText = this.style.cssText + "-webkit-overflow-scrolling: touch;"
+        
+        this.style.overflow = "auto"
+        
+        // this.scrollsX = YES;
+        // this.scrollsY = YES;
+        
+        this.viewHTMLElement.addEventListener("scroll", function (this: UINativeScrollView, event: UIEvent) {
+            
+            
+            this.didScrollToPosition(new UIPoint(this.viewHTMLElement.scrollLeft, this.viewHTMLElement.scrollTop))
+            
+            this.broadcastEventInSubtree({
+                
+                name: UIView.broadcastEventName.PageDidScroll,
+                parameters: nil
+                
+            })
+            
+            
+        }.bind(this))
+        
+        
+    }
+    
+    
+    
+    
+    
+    didScrollToPosition(offsetPosition: UIPoint) {
+        
+        
+        
+    }
+    
+    
+    
+    get scrollsX() {
+        const result = (this.style.overflowX == "scroll")
+        return result
+    }
+    
+    set scrollsX(scrolls: boolean) {
+        if (scrolls) {
+            this.style.overflowX = "scroll"
+        }
+        else {
+            this.style.overflowX = "hidden"
+        }
+    }
+    
+    
+    
+    get scrollsY() {
+        const result = (this.style.overflowY == "scroll")
+        return result
+    }
+    
+    set scrollsY(scrolls: boolean) {
+        if (scrolls) {
+            this.style.overflowY = "scroll"
+        }
+        else {
+            this.style.overflowY = "hidden"
+        }
+    }
+    
+    
+    
+    get contentOffset() {
+        const result = new UIPoint(this.viewHTMLElement.scrollLeft, this.viewHTMLElement.scrollTop)
+        return result
+    }
+    
+    
+    set contentOffset(offsetPoint: UIPoint) {
+        
+        if (this.animationDuration) {
+            
+            this.scrollXTo(this.viewHTMLElement, offsetPoint.x, this.animationDuration)
+            this.scrollYTo(this.viewHTMLElement, offsetPoint.y, this.animationDuration)
+            
+            return
+            
+        }
+        
+        
+        this.viewHTMLElement.scrollLeft = offsetPoint.x
+        this.viewHTMLElement.scrollTop = offsetPoint.y
+        
+    }
+    
+    
+    scrollToBottom() {
+        
+        this.contentOffset = new UIPoint(this.contentOffset.x, this.scrollSize.height - this.frame.height)
+        
+    }
+    
+    scrollToTop() {
+        
+        this.contentOffset = new UIPoint(this.contentOffset.x, 0)
+        
+    }
+    
+    get isScrolledToBottom() {
+        
+        return this.contentOffset.isEqualTo(new UIPoint(this.contentOffset.x, this.scrollSize.height -
+            this.frame.height))
+        
+    }
+    
+    get isScrolledToTop() {
+        
+        return this.contentOffset.isEqualTo(new UIPoint(this.contentOffset.x, 0))
+        
+    }
+    
+    
+    
+    
+    
+    scrollYTo(element, to, duration) {
+        
+        duration = duration * 1000
+    
+        const start = element.scrollTop
+        const change = to - start
+        const increment = 10
+    
+        const animateScroll = function (elapsedTime) {
+            elapsedTime += increment
+            const position = this.easeInOut(elapsedTime, start, change, duration)
+            element.scrollTop = position
+            if (elapsedTime < duration) {
+                setTimeout(function () {
+                    animateScroll(elapsedTime)
+                }, increment)
+            }
+        }.bind(this)
+    
+        animateScroll(0)
+    }
+    
+    scrollXTo(element, to, duration) {
+        
+        duration = duration * 1000
+    
+        const start = element.scrollTop
+        const change = to - start
+        const increment = 10
+    
+        const animateScroll = function (elapsedTime) {
+            elapsedTime += increment
+            const position = this.easeInOut(elapsedTime, start, change, duration)
+            element.scrollLeft = position
+            if (elapsedTime < duration) {
+                setTimeout(function () {
+                    animateScroll(elapsedTime)
+                }, increment)
+            }
+        }.bind(this)
+    
+        animateScroll(0)
+    }
+    
+    easeInOut(currentTime, start, change, duration) {
+        currentTime /= duration / 2
+        if (currentTime < 1) {
+            return change / 2 * currentTime * currentTime + start
+        }
+        currentTime -= 1
+        return -change / 2 * (currentTime * (currentTime - 2) - 1) + start
+    }
+    
+    
+    
+    
+    
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+