@compass-framework/core 1.0.0

package/include/View.d.ts

@@ -0,0 +1,342 @@
+import {
+  Runnable,
+  List,
+  Interface,
+  Nullable,
+} from "@compass-framework/library";
+import { Context } from "./Context";
+import { AttributeSet } from "./AttributeSet";
+import { Canvas } from "./Canvas";
+import { ViewGroup } from "./ViewGroup";
+import { Drawable } from "./Drawable";
+import { MotionEvent } from "./MotionEvent";
+import { Matrix } from "./Matrix";
+import { Resources } from "./Resources";
+import { ViewParent } from "./ViewParent";
+import { KeyEvent } from "./KeyEvent";
+import { Rect } from "./Rect";
+import { ViewOutlineProvider } from "./ViewOutlineProvider";
+import { Outline } from "./Outline";
+import { Animation } from "./Animation";
+import { Transformation } from "./Transformation";
+import { ViewTreeObserver } from "./ViewTreeObserver";
+import { ViewOverlay } from "./ViewOverlay";
+import { Configuration } from "./Configuration";
+import { DensityMetrics } from "./DensityMetrics";
+
+export declare class View implements Drawable.Callback {
+  public static resolveSize(size: number, measureSpec: number): number;
+  public static getMode(measureSpec: number): number;
+  public static getDefaultSize(size: number, measureSpec: number): number;
+
+  public static INVISIBLE: number;
+  public static GONE: number;
+  public static VISIBLE: number;
+
+  public constructor(context: Context);
+  public constructor(context: Context, attrs: AttributeSet);
+
+  public invalidateDrawable(who: Drawable): void;
+
+  public scheduleDrawable(who: Drawable, what: Runnable, when: number): void;
+
+  public unScheduleDrawable(who: Drawable, what: Runnable): void;
+
+  public isFocusable(): boolean;
+
+  public isFocusableInTouchMode(): boolean;
+
+  public isFocused(): boolean;
+
+  public invalidate(): void;
+
+  public invalidateOutline(): void;
+
+  public measure(widthMeasureSpec: number, heightMeasureSpec: number): void;
+
+  public layout(left: number, top: number, right: number, bottom: number): void;
+
+  public draw(canvas: Canvas): void;
+
+  public post(action:Runnable): boolean;
+
+  public removeCallbacks(action: Runnable): boolean;
+
+  public hasFocus(): boolean;
+
+  public requestLayout(): void;
+
+  public requestFocus(): boolean;
+
+  public createViewQuery(): View.ViewQuery;
+  public createViewQuery(resources: Resources): View.ViewQuery;
+
+  public clearFocus(): void;
+
+  public addOnAttachStateChangeListener(listener:View.OnAttachStateChangeListener): void;
+
+  public removeOnAttachStateChangeListener(listener:View.OnAttachStateChangeListener): void;
+
+  public addOnLayoutChangeListener(listener: View.OnLayoutChangeListener): void;
+
+  public removeOnLayoutChangeListener(listener: View.OnLayoutChangeListener): void;
+
+  public scrollTo(x: number, y: number): void;
+
+  public scrollBy(x: number, y: number): void;
+
+  public performClick(): void;
+
+  public startAnimation(animation:Animation) : void;
+
+  public onDraw(canvas: Canvas): void;
+
+  public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void;
+
+  public onLayout(changed: boolean, left: number, top: number, right: number, bottom: number): void;
+
+  public onConfigurationChanged(newConfig: Configuration): void;
+
+  public getAlpha(): number;
+
+  public getWidth(): number;
+
+  public getHeight(): number;
+
+  public getMatrix(): Matrix;
+
+  public getParent(): ViewParent;
+
+  public getId(): number;
+
+  public getPivotX(): number;
+
+  public getPivotY(): number;
+
+  public getX(): number;
+
+  public getY(): number;
+
+  public getDensityMetrics(): DensityMetrics;
+
+  public getScrollX(): number;
+
+  public getScrollY(): number;
+
+  public getParent(): ViewParent;
+
+  public getVisibility(): number;
+
+  public getLayoutParams(): ViewGroup.LayoutParams;
+
+  public getContext(): Context;
+
+  public getBackground(): Drawable;
+
+  public getRotation(): number;
+
+  public getTranslationX(): number;
+
+  public getTranslationY(): number;
+
+  public getScaleX(): number;
+
+  public getScaleY(): number;
+
+  public getOverlay(): ViewOverlay;
+
+  public getViewTreeObserver(): ViewTreeObserver;
+
+  public getOutlineProvider(): ViewOutlineProvider;
+
+  public getLocationOnScreen(location: number[]): void;
+
+  public getPaddingTop(): number;
+
+  public getPaddingBottom(): number;
+
+  public getPaddingLeft(): number;
+
+  public getPaddingRight(): number;
+
+  public getResources(): Resources;
+
+  public getRawPaddingLeft(): number;
+
+  public getRawPaddingTop(): number;
+
+  public getRawPaddingRight(): number;
+
+  public getRawPaddingBottom(): number;
+
+  public setHovered(hovered: boolean): void;
+
+  public setPivotX(x: number): void;
+
+  public setPivotY(y: number): void;
+
+  public setScaleX(x: number): number;
+
+  public setScaleY(y: number): number;
+
+  public setDrawingCacheEnabled(enabled: boolean): void;
+
+  public setBackgroundColor(color: number): void;
+
+  public setBackgroundDrawable(drawable: Drawable): void;
+
+  public setWillNotDraw(willNotDraw: boolean) :void;
+
+  public setMeasuredDimension(measuredWidth: number, measuredHeight: number): void;
+
+  public setAlpha(alpha: number): void;
+
+  public setVisibility(visibility: number): void;
+
+  public setOutlineProvider(provider: ViewOutlineProvider): void;
+
+  public setFocusable(focusable: boolean): void;
+
+  public setFocusableInTouchMode(focusableInTouchMode: boolean): void;
+
+  public setOnClickListener(l: View.OnClickListener): void;
+
+  public setOnFinishInflateListener(l: View.OnFinishInflateListener): void;
+
+  public setOnKeyListener(l: View.OnKeyListener): void;
+
+  public setOnTouchListener(l: View.OnTouchListener): void;
+
+  public setClickable(clickable: boolean): void;
+
+  public setOnGenericMotionListener(l: View.OnGenericMotionListener): void;
+
+  public setPadding(left: number, top: number, right: number, bottom: number): void;
+
+  public setLayoutParams(params: ViewGroup.LayoutParams): void;
+
+  public setRotation(rotation: number): void;
+
+  public setClipToOutline(clipToOutline: boolean): void;
+
+  public setTranslationX(translationX: number): void;
+
+  public setTranslationY(translationY: number): void;
+
+  public setOnHoverListener(l: View.OnHoverListener): void;
+
+  public setHoverCursor(cursor: string): void;
+
+  public setHoverDrawable(drawable: Drawable): void;
+
+  public setOnFocusChangeListener(l: View.OnFocusChangeListener): void;
+}
+
+export declare namespace View {
+  export class ViewRadiusOutlineProvider extends ViewOutlineProvider {
+    public constructor(view: View, ltr: number, lbr: number, rtr: number, rbr: number);
+
+    public onConfigurationChanged(newConfig: Configuration): void;
+
+    public getOutline(view: View, outline: Outline): void;
+
+    public setRadius(value: number): void;
+
+    public setLeftBottomRadius(value: number): void;
+
+    public setLeftTopRadius(value: number): void;
+
+    public setRightBottomRadius(value: number): void;
+
+    public setRightTopRadius(value: number): void;
+  }
+
+  export class AttachInfo {
+    public getTransparentLocation(): Array<number>;
+
+    public getInvalidateChildLocation(): Array<number>;
+
+    public getTmpMatrix(): Matrix;
+
+    public getTmpOutline(): Outline;
+
+    public getTmpTransformLocation(): Array<number>;
+
+    public getTmpTransformRect(): Rect;
+
+    public getTransformation(): Transformation;
+  }
+
+  export class ViewQuery {
+    public findViewById<T extends View>(id: string): Nullable<T>;
+
+    public findViewByTag<T extends View>(tag: string): Nullable<T>;
+
+    public findViewsWithTag<T extends View>(tag: string): List<T>;
+  }
+
+  export class MeasureSpec {
+    public static MODE_SHIFT: number;
+    public static MODE_MASK: number;
+    public static UNSPECIFIED: number;
+    public static EXACTLY: number;
+    public static AT_MOST: number;
+
+    public static makeMeasureSpec(size: number, mode: number): number;
+
+    public static makeSafeMeasureSpec(size: number, mode: number): number;
+
+    public static getMode(measureSpec: number): number;
+
+    public static getSize(measureSpec: number): number;
+
+    public static adjust(measureSpec: number, delta: number): number;
+  }
+
+  export const OnAttachStateChangeListenerInterface: Interface<OnAttachStateChangeListener>;
+  export interface OnAttachStateChangeListener {
+    onViewAttachedToWindow(v: View): void;
+
+    onViewDetachedFromWindow(v: View): void;
+  }
+
+  export const OnTouchListenerInterface:Interface<OnTouchListener>;
+  export interface OnTouchListener {
+    onTouch(v: View, event: MotionEvent): boolean;
+  }
+
+  export const OnClickListenerInterface:Interface<OnClickListener>;
+  export interface OnClickListener {
+    onClick(v: View): void;
+  }
+
+  export const OnHoverListenerInterface: Interface<OnHoverListener>;
+  export interface OnHoverListener {
+    onHover(v: View, event: MotionEvent): boolean;
+  }
+
+  export const OnKeyListenerInterface:Interface<OnKeyListener>;
+  export interface OnKeyListener {
+    onKey(v: View, keyCode: number, event: KeyEvent): boolean;
+  }
+
+  export const OnFocusChangeListenerInterface:Interface<OnFocusChangeListener>;
+  export interface OnFocusChangeListener {
+    onFocusChange(v: View, hasFocus: boolean): void;
+  }
+
+  export const OnGenericMotionListenerInterface:Interface<OnGenericMotionListener>;
+  export interface OnGenericMotionListener {
+    onGenericMotion(v: View, event: MotionEvent): boolean;
+  }
+
+  export const OnLayoutChangeListenerInterface: Interface<OnLayoutChangeListener>;
+  export interface OnLayoutChangeListener {
+    onLayoutChange(v: View, left: number, top: number, right: number, bottom: number, oldLeft: number, oldTop: number, oldRight: number, oldBottom: number):void;
+  }
+
+  export const OnFinishInflateListenerInterface: Interface<OnFinishInflateListener>;
+  export interface OnFinishInflateListener {
+    onViewFinishInflate(v: View): void;
+  }
+}

package/include/ViewGroup.d.ts

@@ -0,0 +1,108 @@
+import { View } from "./View";
+import { AttributeSet } from "./AttributeSet";
+import { Context } from "./Context";
+import { Configuration } from "./Configuration";
+import { ViewParent } from "./ViewParent";
+import { MotionEvent } from "./MotionEvent";
+import { DensityMetrics } from "./DensityMetrics";
+
+export declare abstract class ViewGroup extends View implements ViewParent {
+  public static FLAG_USE_CHILD_DRAWING_ORDER: number;
+  public static FLAG_CLIP_CHILDREN: number;
+  public static FLAG_CLIP_TO_PADDING: number;
+
+  public static getChildMeasureSpec(spec: number, padding: number, childDimension: number): number;
+
+  public isChildrenDrawingOrderEnabled(): boolean;
+
+  public onViewAdded(child:View): void;
+
+  public onViewRemoved(child:View):void;
+
+  public addView(child: View): View;
+  public addView(child: View, index: number): View;
+  public addView(child: View, params: ViewGroup.LayoutParams): View;
+  public addView(child: View, index: number, params: ViewGroup.LayoutParams): View;
+
+  public removeView(view: View): void;
+
+  public removeViewAt(index: number): void;
+
+  public removeAllViews(): void;
+
+  public indexOfChild(child: View): number;
+
+  public generateLayoutParams(attribute: AttributeSet): ViewGroup.LayoutParams;
+  public generateLayoutParams(params: ViewGroup.LayoutParams): ViewGroup.LayoutParams;
+
+  public dispatchTouchEvent(ev: MotionEvent): boolean;
+
+  public getChildCount(): number;
+
+  public getChildAt(index: number): View;
+
+  public getClipChildren() :boolean;
+
+  public getClipToPadding():boolean;
+
+  public getChildDrawingOrder(childCount: number, i: number): number;
+
+  public setClipChildren(clipChildren: boolean): void;
+
+  public setClipToPadding(clipToPadding: boolean): void;
+
+  public setChildrenDrawingOrderEnabled(enabled: boolean): void;
+}
+
+export declare namespace ViewGroup {
+  class LayoutParams {
+    public static MATCH_PARENT: number;
+    public static WRAP_CONTENT: number;
+
+    public constructor(context: Context);
+
+    public onConfigurationChanged(newConfig: Configuration): void;
+
+    public getDensityMetrics(): DensityMetrics;
+
+    public getWidth(): number;
+
+    public getHeight(): number;
+
+    public getRawWidth(): number;
+
+    public getRawHeight(): number;
+
+    public setWidth(width: number): void;
+
+    public setHeight(height: number): void;
+  }
+
+  class MarginLayoutParams extends LayoutParams {
+    public setLeftMargin(margin: number): void;
+
+    public setTopMargin(margin: number): void;
+
+    public setRightMargin(margin: number): void;
+
+    public setBottomMargin(margin: number): void;
+
+    public setMargins(left: number, top: number, right: number, bottom: number): void;
+
+    public getLeftMargin(): number;
+
+    public getTopMargin(): number;
+
+    public getRightMargin(): number;
+
+    public getBottomMargin(): number;
+
+    public getRawLeftMargin(): number;
+
+    public getRawTopMargin(): number;
+
+    public getRawRightMargin(): number;
+
+    public getRawBottomMargin(): number;
+  }
+}

package/include/ViewGroupOverlay.d.ts

@@ -0,0 +1,11 @@
+import { ViewOverlay } from "./ViewOverlay";
+import { Drawable } from "./Drawable";
+import { View } from "./View";
+
+export declare class ViewGroupOverlay extends ViewOverlay {
+  public add(drawable: Drawable): void;
+  public add(view: View): void;
+
+  public remove(drawable: Drawable): void;
+  public remove(view: View): void;
+}

package/include/ViewOutlineProvider.d.ts

@@ -0,0 +1,8 @@
+import { Outline } from "./Outline";
+import { View } from "./View";
+
+export declare abstract class ViewOutlineProvider {
+  public static BACKGROUND: ViewOutlineProvider;
+
+  public abstract getOutline(view:View, outline:Outline): void;
+}

package/include/ViewOverlay.d.ts

@@ -0,0 +1,16 @@
+import { Drawable } from "./Drawable";
+import { ViewGroup } from "./ViewGroup";
+
+export declare class ViewOverlay {
+  public add(drawable: Drawable): void;
+
+  public remove(drawable: Drawable): void;
+
+  public isEmpty(): boolean;
+
+  public clear(): void;
+
+  public getOverlayView(): ViewGroup;
+
+  public setAutoSizeDrawableInOverlay(autoSize: boolean): void;
+}

package/include/ViewParent.d.ts

@@ -0,0 +1,5 @@
+import { Nullable } from "@compass-framework/library";
+
+export interface ViewParent {
+  getParent(): Nullable<ViewParent>;
+}

package/include/ViewTreeObserver.d.ts

@@ -0,0 +1,33 @@
+import { Interface } from "@compass-framework/library";
+import { View } from "./View";
+
+export declare class ViewTreeObserver {
+  public addOnGlobalLayoutListener(listener: ViewTreeObserver.OnGlobalLayoutListener) :void;
+
+  public removeGlobalOnLayoutListener(victim: ViewTreeObserver.OnGlobalLayoutListener):void;
+
+  public addOnPreDrawListener(listener: ViewTreeObserver.OnPreDrawListener):void;
+
+  public removeOnPreDrawListener(victim: ViewTreeObserver.OnPreDrawListener) :void;
+
+  public addOnGlobalFocusChangeListener(listener: ViewTreeObserver.OnGlobalFocusChangeListener): void;
+
+  public removeOnGlobalFocusChangeListener(victim: ViewTreeObserver.OnGlobalFocusChangeListener): void;
+}
+
+export declare namespace ViewTreeObserver {
+  export const OnGlobalLayoutListenerInterface:Interface<OnGlobalLayoutListener>;
+  export interface OnGlobalLayoutListener {
+    onGlobalLayout(): void;
+  }
+
+  export const OnGlobalFocusChangeListenerInterface:Interface<OnGlobalFocusChangeListener>;
+  export interface OnGlobalFocusChangeListener {
+    onGlobalFocusChanged(oldFocus: View, newFocus: View): void;
+  }
+
+  export const OnPreDrawListenerInterface:Interface<OnPreDrawListener>;
+  export interface OnPreDrawListener {
+    onPreDraw(): boolean;
+  }
+}

package/include/WindowContext.d.ts

@@ -0,0 +1,9 @@
+import { Context } from "./Context";
+import { ICursor } from "./ICursor";
+import { ApplicationFrameContext } from "./ApplicationFrameContext";
+
+export declare class WindowContext extends Context {
+  public getApplicationFrameContext(): ApplicationFrameContext;
+
+  public getWindowCursor(): ICursor;
+}

package/include/WindowManager.d.ts

@@ -0,0 +1,13 @@
+import { ViewGroup } from "./ViewGroup";
+
+export declare class WindowManager {
+
+}
+
+export declare namespace WindowManager {
+  export class LayoutParams extends ViewGroup.LayoutParams {
+    public setAlpha(alpha: number): void;
+
+    public setGravity(gravity: number): void;
+  }
+}

package/include/XMLLayoutParser.d.ts

@@ -0,0 +1,9 @@
+import { Context } from "./Context";
+import { View } from "./View";
+import { ViewGroup } from "./ViewGroup";
+
+export declare class XMLLayoutParser {
+  public static from(context: Context): XMLLayoutParser;
+
+  public parseLayoutXML<T = View>(root: ViewGroup, xml: string, attach?: boolean): T;
+}

package/include/XMLResourcesParser.d.ts

@@ -0,0 +1,8 @@
+import { XML } from "@compass-framework/library";
+import { Context } from "./Context";
+
+declare class XMLResourcesParser {
+  public static from(context: Context): XMLResourcesParser;
+
+  public parseResourceXML(xml: XML): void;
+}

package/include/XMLViewFactoryRegistry.d.ts

@@ -0,0 +1,42 @@
+import { BiFunction, Class } from "@compass-framework/library";
+import { View } from "./View";
+import { Context } from "./Context";
+import { AttributeSet } from "./AttributeSet";
+
+export declare class XMLViewFactoryRegistry {
+  public hasViewFactory(name: string): boolean;
+
+  public registryViewFactory<T extends View>(name: string, factory: XMLViewFactoryRegistry.Factory<T>, overwrite?: boolean): XMLViewFactoryRegistry;
+
+  public removeViewFactory(name: string): XMLViewFactoryRegistry;
+
+  public registryViewClass<T extends View>(name: string, clazz: Class<T>, overwrite?: boolean): XMLViewFactoryRegistry;
+
+  public setDefaultAttribute(name: string, value: string): XMLViewFactoryRegistry;
+
+  public removeDefaultAttribute(name: string): XMLViewFactoryRegistry;
+
+  public getViewFactory<T extends View>(name: string): XMLViewFactoryRegistry.Factory<T>;
+
+  public getDefaultAttribute(attr?: XMLViewFactoryRegistry.Attribute): XMLViewFactoryRegistry.Attribute;
+}
+
+export declare namespace XMLViewFactoryRegistry {
+  export type Attribute = { [key: string]: string };
+
+  export interface Factory<T extends View> {
+    getView(context: Context, attrs: AttributeSet): T;
+  }
+
+  export class ViewFactory<T extends View> implements Factory<T> {
+    public constructor(clazz:Class<View>);
+
+    public getView(context: Context, attrs: AttributeSet): T;
+  }
+
+  export class CustomFactory<T extends View> implements Factory<T> {
+    public constructor(callback: BiFunction<Context, AttributeSet, View>);
+
+    public getView(context: Context, attrs: AttributeSet): T;
+  }
+}