@nativescript/core 9.0.0-next-09-24-2025-17985801416 → 9.0.0-next-10-06-2025-18277360121

package/platforms/android/java/org/nativescript/widgets/ItemSpec.java

@@ -0,0 +1,56 @@
+package org.nativescript.widgets;
+
+/**
+ * @author hhristov
+ */
+public class ItemSpec {
+
+	private final int _value;
+	private final GridUnitType _unitType;
+
+	public ItemSpec() {
+		this(1, GridUnitType.star);
+	}
+
+	public ItemSpec(int value, GridUnitType unitType) {
+		this._value = value;
+		this._unitType = unitType;
+	}
+
+	GridLayout owner;
+	int _actualLength = 0;
+
+	@Override
+	public boolean equals(Object o) {
+		if (!(o instanceof ItemSpec)) {
+			return false;
+		}
+
+		ItemSpec other = (ItemSpec) o;
+		return (this._unitType == other._unitType) && (this._value == other._value) && (this.owner == other.owner);
+	}
+
+	public GridUnitType getGridUnitType() {
+		return this._unitType;
+	}
+
+	public boolean getIsAbsolute() {
+		return this._unitType == GridUnitType.pixel;
+	}
+
+	public boolean getIsAuto() {
+		return this._unitType == GridUnitType.auto;
+	}
+
+	public boolean getIsStar() {
+		return this._unitType == GridUnitType.star;
+	}
+
+	public int getValue() {
+		return this._value;
+	}
+
+	public int getActualLength() {
+		return this._actualLength;
+	}
+}

package/platforms/android/java/org/nativescript/widgets/LayoutBase.java

@@ -0,0 +1,98 @@
+package org.nativescript.widgets;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.Gravity;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+
+/**
+ * @author hhristov
+ */
+public abstract class LayoutBase extends ViewGroup {
+	private boolean passThroughParent;
+
+	public LayoutBase(Context context, AttributeSet attrs, int defStyleAttr) {
+		super(context, attrs, defStyleAttr);
+	}
+
+	public LayoutBase(Context context) {
+		super(context);
+	}
+
+	@Override
+	protected LayoutParams generateDefaultLayoutParams() {
+		return new CommonLayoutParams();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public LayoutParams generateLayoutParams(AttributeSet attrs) {
+		return new CommonLayoutParams();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	protected boolean checkLayoutParams(LayoutParams p) {
+		return p instanceof CommonLayoutParams;
+	}
+
+	@Override
+	protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams from) {
+		if (from instanceof CommonLayoutParams)
+			return new CommonLayoutParams((CommonLayoutParams) from);
+
+		if (from instanceof FrameLayout.LayoutParams)
+			return new CommonLayoutParams((FrameLayout.LayoutParams) from);
+
+		if (from instanceof ViewGroup.MarginLayoutParams)
+			return new CommonLayoutParams((ViewGroup.MarginLayoutParams) from);
+
+		return new CommonLayoutParams(from);
+	}
+
+	@Override
+	public boolean shouldDelayChildPressedState() {
+		return false;
+	}
+
+	@Override
+	public boolean onTouchEvent(MotionEvent event) {
+		if (!this.passThroughParent) {
+			return super.onTouchEvent(event);
+		}
+
+		// LayoutBase.onTouchEvent(ev) execution means no interactive child view handled
+		// the event so we let the event pass through to parent view of the layout container
+		// because passThroughParent is set to true
+		return false;
+	}
+
+	protected static int getGravity(View view) {
+		int gravity = -1;
+		LayoutParams params = view.getLayoutParams();
+		if (params instanceof FrameLayout.LayoutParams) {
+			gravity = ((FrameLayout.LayoutParams) params).gravity;
+		}
+
+		if (gravity == -1) {
+			gravity = Gravity.FILL;
+		}
+
+		return gravity;
+	}
+
+	public boolean getPassThroughParent() {
+		return this.passThroughParent;
+	}
+
+	public void setPassThroughParent(boolean value) {
+		this.passThroughParent = value;
+	}
+}

package/platforms/android/java/org/nativescript/widgets/LinearGradientDefinition.java

@@ -0,0 +1,46 @@
+package org.nativescript.widgets;
+
+/**
+ * Created by Vultix on 3/12/2018.
+ */
+public class LinearGradientDefinition {
+	private final float startX;
+	private final float startY;
+	private final float endX;
+	private final float endY;
+	private final int[] colors;
+	private final float[] stops;
+
+	public float getStartX() {
+		return startX;
+	}
+
+	public float getStartY() {
+		return startY;
+	}
+
+	public float getEndX() {
+		return endX;
+	}
+
+	public float getEndY() {
+		return endY;
+	}
+
+	public int[] getColors() {
+		return colors;
+	}
+
+	public float[] getStops() {
+		return stops;
+	}
+
+	public LinearGradientDefinition(float startX, float startY, float endX, float endY, int[] colors, float[] stops) {
+		this.startX = startX;
+		this.startY = startY;
+		this.endX = endX;
+		this.endY = endY;
+		this.colors = colors;
+		this.stops = stops;
+	}
+}

package/platforms/android/java/org/nativescript/widgets/Orientation.java

@@ -0,0 +1,9 @@
+package org.nativescript.widgets;
+
+/**
+ * @author hhristov
+ */
+public enum Orientation {
+	horizontal,
+	vertical
+}

package/platforms/android/java/org/nativescript/widgets/OriginPoint.java

@@ -0,0 +1,74 @@
+package org.nativescript.widgets;
+
+import android.view.View;
+
+import java.util.WeakHashMap;
+
+/**
+ * A class encapsulating the logic of setting an origin point.
+ * The origin acts as a pivot point but is relative to the View size,
+ * Where 0 is the left or top of the view, 0.5 is at the middle and 1 is right or bottom.
+ * Under the hood the pivot point is set but is updated when the View's layout is changed.
+ */
+public class OriginPoint {
+	private static WeakHashMap<View, PivotSetter> layoutListeners;
+
+	public static void setX(View view, float x) {
+		getSetter(view).setOriginX(view, x);
+	}
+
+	public static void setY(View view, float y) {
+		getSetter(view).setOriginY(view, y);
+	}
+
+	private static PivotSetter getSetter(View view) {
+		PivotSetter setter = null;
+
+		if (layoutListeners == null) {
+			layoutListeners = new WeakHashMap<>();
+		} else {
+			setter = layoutListeners.get(view);
+		}
+
+		if (setter == null) {
+			setter = new PivotSetter();
+			view.addOnLayoutChangeListener(setter);
+			layoutListeners.put(view, setter);
+		}
+
+		return setter;
+	}
+
+	private static class PivotSetter implements View.OnLayoutChangeListener {
+		private float originX;
+		private float originY;
+
+		public PivotSetter() {
+			originX = 0.5f;
+			originY = 0.5f;
+		}
+
+		public void setOriginX(View view, float x) {
+			originX = x;
+			updateX(view, view.getWidth());
+		}
+
+		public void setOriginY(View view, float y) {
+			originY = y;
+			updateY(view, view.getHeight());
+		}
+
+		public void onLayoutChange(View view, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
+			updateX(view, right - left);
+			updateY(view, bottom - top);
+		}
+
+		private void updateX(View view, int width) {
+			view.setPivotX(originX * width);
+		}
+
+		private void updateY(View view, int height) {
+			view.setPivotY(originY * height);
+		}
+	}
+}

package/platforms/android/java/org/nativescript/widgets/ScrollSavedState.java

@@ -0,0 +1,63 @@
+package org.nativescript.widgets;
+
+import android.os.Build;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.view.View.BaseSavedState;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+/**
+ * @author CatchABus
+ */
+class ScrollSavedState extends BaseSavedState {
+  public int scrollOffsetFromStart;
+
+  ScrollSavedState(Parcelable superState) {
+    super(superState);
+  }
+
+  public ScrollSavedState(Parcel source) {
+    super(source);
+    scrollOffsetFromStart = source.readInt();
+  }
+
+  @RequiresApi(Build.VERSION_CODES.N)
+  public ScrollSavedState(Parcel source, ClassLoader loader) {
+    super(source, loader);
+    scrollOffsetFromStart = source.readInt();
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    super.writeToParcel(dest, flags);
+    dest.writeInt(scrollOffsetFromStart);
+  }
+
+  @NonNull
+  @Override
+  public String toString() {
+    return "ScrollSavedState{"
+      + Integer.toHexString(System.identityHashCode(this))
+      + " scrollPosition=" + scrollOffsetFromStart
+      + "}";
+  }
+
+  public static final Creator<ScrollSavedState> CREATOR = new ClassLoaderCreator<ScrollSavedState>() {
+    public ScrollSavedState createFromParcel(Parcel in, ClassLoader loader)
+    {
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.N ? new ScrollSavedState(in, loader) : new ScrollSavedState(in);
+    }
+
+    @Override
+    public ScrollSavedState createFromParcel(Parcel in)
+    {
+        return createFromParcel(in, null);
+    }
+
+    public ScrollSavedState[] newArray(int size) {
+      return new ScrollSavedState[size];
+    }
+  };
+}

package/platforms/android/java/org/nativescript/widgets/SegmentedBarColorDrawable.java

@@ -0,0 +1,27 @@
+package org.nativescript.widgets;
+
+import android.graphics.Paint;
+import android.graphics.drawable.ColorDrawable;
+
+import androidx.annotation.ColorInt;
+
+/**
+ * Created by hhristov on 2/23/17.
+ */
+
+public class SegmentedBarColorDrawable extends ColorDrawable {
+
+	private final float thickness;
+
+	public SegmentedBarColorDrawable(@ColorInt int color, float thickness) {
+		super(color);
+		this.thickness = thickness;
+	}
+
+	public void draw(android.graphics.Canvas canvas) {
+		Paint p = new Paint();
+		p.setColor(this.getColor());
+		p.setStyle(android.graphics.Paint.Style.FILL);
+		canvas.drawRect(0, this.getBounds().height() - thickness, this.getBounds().width(), this.getBounds().height(), p);
+	}
+}

package/platforms/android/java/org/nativescript/widgets/StackLayout.java

@@ -0,0 +1,231 @@
+package org.nativescript.widgets;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.View;
+import android.util.AttributeSet;
+
+/**
+ * @author hhristov
+ */
+public class StackLayout extends LayoutBase {
+	static final String TAG = "JS";
+	private int _totalLength = 0;
+	private Orientation _orientation = Orientation.vertical;
+
+	public StackLayout(Context context) {
+		this(context, null);
+	}
+	public StackLayout(Context context, AttributeSet attrs) {
+		this(context, attrs, 0);
+	}
+	public StackLayout(Context context, AttributeSet attrs, int defStyleAttr) {
+		super(context, attrs, defStyleAttr);
+	}
+
+	public Orientation getOrientation() {
+		return this._orientation;
+	}
+
+	public void setOrientation(Orientation value) {
+		this._orientation = value;
+		this.requestLayout();
+	}
+
+	@Override
+	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+		CommonLayoutParams.adjustChildrenLayoutParams(this, widthMeasureSpec, heightMeasureSpec);
+
+		int childState = 0;
+		int measureWidth = 0;
+		int measureHeight = 0;
+
+		int width = MeasureSpec.getSize(widthMeasureSpec);
+		int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+
+		int height = MeasureSpec.getSize(heightMeasureSpec);
+		int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+
+		boolean isVertical = this._orientation == Orientation.vertical;
+		int verticalPadding = this.getPaddingTop() + this.getPaddingBottom();
+		int horizontalPadding = this.getPaddingLeft() + this.getPaddingRight();
+
+		int count = this.getChildCount();
+		int measureSpecMode;
+		int remainingLength;
+
+		int mode = isVertical ? heightMode : widthMode;
+		if (mode == MeasureSpec.UNSPECIFIED) {
+			measureSpecMode = MeasureSpec.UNSPECIFIED;
+			remainingLength = 0;
+		} else {
+			measureSpecMode = MeasureSpec.AT_MOST;
+			remainingLength = isVertical ? height - verticalPadding : width - horizontalPadding;
+		}
+
+		int childMeasureSpec;
+		if (isVertical) {
+			int childWidth = (widthMode == MeasureSpec.UNSPECIFIED) ? 0 : width - horizontalPadding;
+			childWidth = Math.max(0, childWidth);
+			childMeasureSpec = MeasureSpec.makeMeasureSpec(childWidth, widthMode);
+		} else {
+			int childHeight = (heightMode == MeasureSpec.UNSPECIFIED) ? 0 : height - verticalPadding;
+			childHeight = Math.max(0, childHeight);
+			childMeasureSpec = MeasureSpec.makeMeasureSpec(childHeight, heightMode);
+		}
+
+		for (int i = 0; i < count; i++) {
+			View child = this.getChildAt(i);
+			if (child.getVisibility() == View.GONE) {
+				continue;
+			}
+
+			if (isVertical) {
+				// Measuring android.widget.ListView, with no height property set, with MeasureSpec.AT_MOST will
+				// result in height required for all list view items or the maximum available space for the StackLayout.
+				// Any following controls will be visible only if enough space left.
+				CommonLayoutParams.measureChild(child, childMeasureSpec, MeasureSpec.makeMeasureSpec(remainingLength, measureSpecMode));
+
+				if (measureSpecMode == MeasureSpec.AT_MOST && this.isUnsizedScrollableView(child)) {
+					Log.e(TAG, "Avoid using ListView or ScrollView with no explicit height set inside StackLayout. Doing so might results in poor user interface performance and a poor user experience.");
+				}
+
+				final int childMeasuredWidth = CommonLayoutParams.getDesiredWidth(child);
+				final int childMeasuredHeight = CommonLayoutParams.getDesiredHeight(child);
+
+				measureWidth = Math.max(measureWidth, childMeasuredWidth);
+				measureHeight += childMeasuredHeight;
+				remainingLength = Math.max(0, remainingLength - childMeasuredHeight);
+			} else {
+				CommonLayoutParams.measureChild(child, MeasureSpec.makeMeasureSpec(remainingLength, measureSpecMode), childMeasureSpec);
+				final int childMeasuredWidth = CommonLayoutParams.getDesiredWidth(child);
+				final int childMeasuredHeight = CommonLayoutParams.getDesiredHeight(child);
+
+				measureHeight = Math.max(measureHeight, childMeasuredHeight);
+				measureWidth += childMeasuredWidth;
+				remainingLength = Math.max(0, remainingLength - childMeasuredWidth);
+			}
+
+			childState = combineMeasuredStates(childState, child.getMeasuredState());
+		}
+
+		// Add in our padding
+		measureWidth += horizontalPadding;
+		measureHeight += verticalPadding;
+
+		// Check against our minimum sizes
+		measureWidth = Math.max(measureWidth, this.getSuggestedMinimumWidth());
+		measureHeight = Math.max(measureHeight, this.getSuggestedMinimumHeight());
+
+		this._totalLength = isVertical ? measureHeight : measureWidth;
+
+		int widthSizeAndState = resolveSizeAndState(measureWidth, widthMeasureSpec, isVertical ? childState : 0);
+		int heightSizeAndState = resolveSizeAndState(measureHeight, heightMeasureSpec, isVertical ? 0 : childState);
+
+		this.setMeasuredDimension(widthSizeAndState, heightSizeAndState);
+	}
+
+	@Override
+	protected void onLayout(boolean changed, int l, int t, int r, int b) {
+		if (this._orientation == Orientation.vertical) {
+			this.layoutVertical(l, t, r, b);
+		} else {
+			this.layoutHorizontal(l, t, r, b);
+		}
+
+		CommonLayoutParams.restoreOriginalParams(this);
+	}
+
+	private void layoutVertical(int left, int top, int right, int bottom) {
+
+		int paddingLeft = this.getPaddingLeft();
+		int paddingRight = this.getPaddingRight();
+		int paddingTop = this.getPaddingTop();
+		int paddingBottom = this.getPaddingBottom();
+
+		int childTop = 0;
+		int childLeft = paddingLeft;
+		int childRight = right - left - paddingRight;
+
+		int gravity = LayoutBase.getGravity(this);
+		final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;
+
+		switch (verticalGravity) {
+			case Gravity.CENTER_VERTICAL:
+				childTop = (bottom - top - this._totalLength) / 2 + paddingTop;
+				break;
+
+			case Gravity.BOTTOM:
+				childTop = bottom - top - this._totalLength + paddingTop;
+				break;
+
+			case Gravity.TOP:
+			case Gravity.FILL_VERTICAL:
+			default:
+				childTop = paddingTop;
+				break;
+		}
+
+		for (int i = 0, count = this.getChildCount(); i < count; i++) {
+			View child = this.getChildAt(i);
+			if (child.getVisibility() == View.GONE) {
+				continue;
+			}
+
+			int childHeight = CommonLayoutParams.getDesiredHeight(child);
+			CommonLayoutParams.layoutChild(child, childLeft, childTop, childRight, childTop + childHeight);
+			childTop += childHeight;
+		}
+	}
+
+	@SuppressLint("RtlHardcoded")
+	private void layoutHorizontal(int left, int top, int right, int bottom) {
+
+		int paddingLeft = this.getPaddingLeft();
+		int paddingRight = this.getPaddingRight();
+		int paddingTop = this.getPaddingTop();
+		int paddingBottom = this.getPaddingBottom();
+
+		int childTop = paddingTop;
+		int childLeft = 0;
+		int childBottom = bottom - top - paddingBottom;
+
+		int gravity = LayoutBase.getGravity(this);
+		final int horizontalGravity = Gravity.getAbsoluteGravity(gravity, this.getLayoutDirection()) & Gravity.HORIZONTAL_GRAVITY_MASK;
+
+		switch (horizontalGravity) {
+			case Gravity.CENTER_HORIZONTAL:
+				childLeft = (right - left - this._totalLength) / 2 + paddingLeft;
+				break;
+
+			case Gravity.RIGHT:
+				childLeft = right - left - this._totalLength + paddingLeft;
+				break;
+
+			case Gravity.LEFT:
+			case Gravity.FILL_HORIZONTAL:
+			default:
+				childLeft = paddingLeft;
+				break;
+		}
+
+		for (int i = 0, count = this.getChildCount(); i < count; i++) {
+			View child = this.getChildAt(i);
+			if (child.getVisibility() == View.GONE) {
+				continue;
+			}
+
+			int childWidth = CommonLayoutParams.getDesiredWidth(child);
+			CommonLayoutParams.layoutChild(child, childLeft, childTop, childLeft + childWidth, childBottom);
+			childLeft += childWidth;
+		}
+	}
+
+	private boolean isUnsizedScrollableView(View child) {
+		LayoutParams childLayoutParams = child.getLayoutParams();
+
+		return childLayoutParams.height == -1 && (child instanceof android.widget.ListView || child instanceof VerticalScrollView);
+	}
+}

package/platforms/android/java/org/nativescript/widgets/StyleableTextView.java

@@ -0,0 +1,50 @@
+package org.nativescript.widgets;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.text.TextPaint;
+
+/**
+ * @author NathanWalker
+ */
+public class StyleableTextView extends androidx.appcompat.widget.AppCompatTextView {
+	int mTextStrokeWidth = 0;
+	int mTextStrokeColor = 0;
+	int mTextColor = 0;
+
+	public StyleableTextView(Context context) {
+		super(context);
+	}
+
+	@Override
+	protected void onDraw(Canvas canvas) {
+		if (mTextStrokeWidth > 0) {
+			_applyStroke(canvas);
+		} else {
+			super.onDraw(canvas);
+		}
+	}
+
+	public void setTextStroke(int width, int color, int textColor) {
+		mTextStrokeWidth = width;
+		mTextStrokeColor = color;
+		mTextColor = textColor;
+	}
+
+	private void _applyStroke(Canvas canvas) {
+		// set paint to fill mode
+		TextPaint p = this.getPaint();
+		p.setStyle(TextPaint.Style.FILL);
+		// draw the fill part of text
+		super.onDraw(canvas);
+		// stroke color and width
+		p.setStyle(TextPaint.Style.STROKE);
+		p.setStrokeWidth(mTextStrokeWidth);
+		this.setTextColor(mTextStrokeColor);
+		// draw stroke
+		super.onDraw(canvas);
+		// draw original text color fill back (fallback to white)
+		p.setStyle(TextPaint.Style.FILL);
+		this.setTextColor(mTextColor != 0 ? mTextColor : 0xffffffff);
+	}
+}

package/platforms/android/java/org/nativescript/widgets/TabIconRenderingMode.java

@@ -0,0 +1,6 @@
+package org.nativescript.widgets;
+
+public enum TabIconRenderingMode {
+	template,
+	original
+}

package/platforms/android/java/org/nativescript/widgets/TabItemSpec.java

@@ -0,0 +1,15 @@
+package org.nativescript.widgets;
+
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+
+public class TabItemSpec {
+	public String title;
+	public int fontSize;
+	public Typeface typeFace;
+	public int iconId;
+	public Drawable iconDrawable;
+	public int imageHeight;
+	public int backgroundColor;
+	public int color;
+}