renetik-android-ui/renetik.android.ui.extensions.view

Package renetik.android.ui.extensions.view

Functions

action

fun View.action(action: CSEvent<Unit>): View

activated

fun View.activated(value: Boolean = true): View

activatedIf

fun View.activatedIf(value: Boolean): View

fun View.activatedIf(property: CSProperty<Boolean>): CSRegistration

inline fun <T> View.activatedIf(property: CSProperty<T>, crossinline condition: (T) -> Boolean): CSRegistration

inline fun <T> View.activatedIf( property1: CSProperty<T>, property2: CSProperty<*>, crossinline condition: (T) -> Boolean): CSRegistration

fun <T, V> View.activatedIf( property1: CSProperty<T>, property2: CSProperty<V>, condition: (T, V) -> Boolean): CSRegistration

fun <T, V, X> View.activatedIf( property1: CSProperty<T>, property2: CSProperty<V>, property3: CSProperty<X>, condition: (T, V, X) -> Boolean): CSRegistration

fun <T, V, X, Y> View.activatedIf( property1: CSProperty<T>, property2: CSProperty<V>, property3: CSProperty<X>, property4: CSProperty<Y>, condition: (T, V, X, Y) -> Boolean): CSRegistration

activateIf

fun <T> View.activateIf(property: CSProperty<T>, value: T): CSRegistration

add

fun <ViewType : View> ViewGroup.add(view: ViewType, index: Int = -1): ViewType

fun <ViewType : View> ViewGroup.add(@LayoutRes layoutId: Int, index: Int = -1): ViewType

fun <ViewType : View> ViewGroup.add( view: ViewType, layout: ViewGroup.LayoutParams, index: Int = -1): ViewType

fun <ViewType : View> ViewGroup.add( @LayoutRes layoutId: Int, layout: ViewGroup.LayoutParams, index: Int = -1): ViewType

afterGlobalLayout

fun <T : View> T.afterGlobalLayout(parent: CSHasRegistrations, function: (View) -> Unit): CSRegistration

alphaToDisabled

fun View.alphaToDisabled(value: Boolean = true)

background

fun <T : View> T.background(@DrawableRes value: Int): T

fun <T : View> T.background(value: CSColorInt): T

backgroundColor

fun <T : View> T.backgroundColor(@ColorInt value: Int): T

backgroundRoundedWithColor

fun <T : View> T.backgroundRoundedWithColor(@ColorInt value: Int, radius: Float = 8.0f)

backgroundTint

fun <T : View> T.backgroundTint(@ColorInt value: Int): T

bottomMargin

fun <T : View> T.bottomMargin(value: Int): T

button

fun View.button(@IdRes id: Int): Button

checkBox

fun View.checkBox(@IdRes id: Int): CheckBox

childAt

fun ViewGroup.childAt(condition: (View) -> Boolean): View?

clear

fun <T : ViewGroup> T.clear(): T

compound

fun View.compound(@IdRes id: Int): CompoundButton

createBitmap

fun <T : View> T.createBitmap(): Bitmap

datePicker

fun View.datePicker(@IdRes id: Int): DatePicker

disabled

fun <T : View> T.disabled(value: Boolean = true): T

disabledByAlpha

fun View.disabledByAlpha(condition: Boolean = true, disable: Boolean = true)

disabledByAlphaIf

fun View.disabledByAlphaIf(property: CSProperty<Boolean>, disable: Boolean = true): CSRegistration

fun <T> View.disabledByAlphaIf( property: CSProperty<T>, disable: Boolean = true, condition: (T) -> Boolean): CSRegistration

fun <T, V> View.disabledByAlphaIf( property1: CSProperty<T>, property2: CSProperty<V>, condition: (T, V) -> Boolean): CSRegistration

disabledByAlphaIfNot

fun View.disabledByAlphaIfNot(property: CSProperty<Boolean>, disable: Boolean = true): CSRegistration

disabledIf

fun <T : View> T.disabledIf(condition: Boolean): T

fun View.disabledIf(property: CSProperty<Boolean>): CSRegistration

fun <T> View.disabledIf(property: CSProperty<T>, condition: (T) -> Boolean): CSRegistration

fun <T, V> View.disabledIf( property1: CSProperty<T>, property2: CSProperty<V>, condition: (T, V) -> Boolean): CSRegistration

editText

fun View.editText(@IdRes id: Int): EditText

enabled

fun <T : View> T.enabled(enabled: Boolean = true): T

enabledByAlphaIf

fun View.enabledByAlphaIf(condition: Boolean)

fun View.enabledByAlphaIf(property: CSProperty<Boolean>): CSRegistration

fun <T> View.enabledByAlphaIf(property: CSProperty<T>, condition: (T) -> Boolean): CSRegistration

fun <T> View.enabledByAlphaIf( property1: CSProperty<T>, property2: CSProperty<*>, condition: (T) -> Boolean): CSRegistration

fun <T, V> View.enabledByAlphaIf( property1: CSProperty<T>, property2: CSProperty<V>, condition: (T, V) -> Boolean): CSRegistration

enabledIf

fun <T : View> T.enabledIf(condition: Boolean): T

endMargin

fun <T : View> T.endMargin(value: Int): T

enterFullScreen

fun View.enterFullScreen()

exitFullscreen

fun View.exitFullscreen()

fadeIn

fun <T : View> T.fadeIn(duration: Int = shortAnimationDuration): ViewPropertyAnimator?

fadeOut

fun <T : View> T.fadeOut( duration: Int = shortAnimationDuration, invisible: Boolean = false, onDone: () -> Unit? = null): ViewPropertyAnimator?

findView

fun <T : View> View.findView(@IdRes id: Int): T?

findViewRecursive

fun <T : View> View.findViewRecursive(id: Int): T?

foregroundTint

fun <T : View> T.foregroundTint(@ColorInt value: Int): T

frame

fun View.frame(@IdRes id: Int): FrameLayout

getRectangleOnScreen

fun View.getRectangleOnScreen(location: IntArray, rectangle: Rect)

gone

fun <T : View> T.gone(animated: Boolean = false): T

goneIf

fun <T : View> T.goneIf(condition: Boolean, animated: Boolean = false): T

fun View.goneIf(property: CSProperty<Boolean>, animated: Boolean = false): CSRegistration

fun <T> View.goneIf( property: CSProperty<T>, animated: Boolean = false, condition: (T) -> Boolean): CSRegistration

fun View.goneIf( property1: CSProperty<Boolean>, property2: CSProperty<Boolean>, animated: Boolean = false): CSRegistration

fun <T, V> View.goneIf( property1: CSProperty<T>, property2: CSProperty<V>, animated: Boolean = false, condition: (T, V) -> Boolean): CSRegistration

group

fun View.group(@IdRes id: Int): ViewGroup

hasSize

fun <T : View> T.hasSize(parent: CSHasRegistrations, onHasSize: (View) -> Unit)

height

fun <T : View> T.height(value: Float): T

fun <T : View> T.height(value: Int): T

heightDp

fun <T : View> T.heightDp(value: Int): T

hide

fun <T : View> T.hide(animated: Boolean = false): T

horizontalMargin

fun <T : View> T.horizontalMargin(value: Int): T

horizontalMarginDp

fun <T : View> T.horizontalMarginDp(value: Int): T

horizontalScroll

fun View.horizontalScroll(@IdRes id: Int): HorizontalScrollView

fun View.id(value: Int): View

imageView

fun View.imageView(@IdRes id: Int): ImageView

inflate

fun <ViewType : View> ViewGroup.inflate(@LayoutRes layoutId: Int): ViewType

invisible

fun <T : View> T.invisible(animated: Boolean = false): T

invisibleIf

fun <T : View> T.invisibleIf(condition: Boolean, animated: Boolean = false): T

fun View.invisibleIf(property: CSProperty<Boolean>, animated: Boolean = false): CSRegistration

fun <T> View.invisibleIf( property: CSProperty<T>, animated: Boolean = false, condition: (T) -> Boolean): CSRegistration

isInside

fun MotionEvent.isInside(view: View): Boolean

isShowing

fun View.isShowing(): Boolean

item

fun Menu.item(id: Int): MenuItem

linear

fun View.linear(@IdRes id: Int): LinearLayout

listView

fun View.listView(@IdRes id: Int): ListView

margin

fun <T : View> T.margin(value: Int): T

marginDp

fun <T : View> T.marginDp(value: Int): T

margins

fun <T : View> T.margins( left: Int, top: Int, right: Int, bottom: Int): T

model

fun <T> View.model(): T?

fun <T> View.model(value: T?): View

modelProperty

fun <T> View.modelProperty(): CSProperty<T?>

numberPicker

fun View.numberPicker(@IdRes id: Int): NumberPicker

onAnimationEnd

fun ViewPropertyAnimator.onAnimationEnd(function: Func): ViewPropertyAnimator

onClick

fun <T : View> T.onClick(onClick: (view: T) -> Unit): T

fun View.onClick(action: CSActionInterface): View

onDestroy

fun View.onDestroy()

onDoubleTap

inline fun <T : View> T.onDoubleTap(crossinline function: (T) -> Unit): T

onGlobalFocus

fun <T : View> T.onGlobalFocus(function: (View?, View?) -> Unit): CSRegistration

onGlobalLayout

fun <T : View> T.onGlobalLayout(function: (CSRegistration) -> void): CSRegistration

onLayoutChange

inline fun View.onLayoutChange(crossinline function: () -> Unit): CSRegistration

onLongClick

fun <T : View> T.onLongClick(onClick: (view: T) -> Unit): T

onScrollChange

fun View.onScrollChange(function: (view: View) -> Unit): CSRegistration

padding

fun <T : View> T.padding(dp: Int = -1, px: Int = -1): T

paddingDp

fun <T : View> T.paddingDp(horizontal: Int = -1, vertical: Int = -1): T

fun <T : View> T.paddingDp( left: Int, top: Int, right: Int, bottom: Int): T

paddingHorizontal

fun <T : View> T.paddingHorizontal(dp: Int = -1, px: Int = -1): T

paddingVertical

fun <T : View> T.paddingVertical(dp: Int = -1, px: Int = -1): T

performTouchDown

fun View.performTouchDown(): Boolean

pressedIf

fun View.pressedIf(value: Boolean): View

fun <T> View.pressedIf( property1: CSProperty<T>, property2: CSProperty<*>, condition: (T) -> Boolean): CSRegistration

fun <T, V> View.pressedIf( property1: CSProperty<T>, property2: CSProperty<V>, condition: (T, V) -> Boolean): CSRegistration

progress

fun View.progress(@IdRes id: Int): ProgressBar

propertyWithTag

fun <T : Any> View.propertyWithTag(@IdRes key: Int, onCreate: () -> T): T

radio

fun View.radio(@IdRes id: Int): RadioButton

remove

fun <T : ViewGroup> T.remove(view: View): T

removeAt

fun ViewGroup.removeAt(index: Int): View

removeFromSuperview

fun <T : View> T.removeFromSuperview(): T

removeSubViews

fun <T : ViewGroup> T.removeSubViews(): T

removeViews

fun ViewGroup.removeViews(from: Int)

scrollView

fun View.scrollView(@IdRes id: Int): ScrollView

fun View.search(@IdRes id: Int): SearchView

seekBar

fun View.seekBar(@IdRes id: Int): SeekBar

selected

fun View.selected(value: Boolean = true): View

selectedIf

fun View.selectedIf(value: Boolean): View

fun View.selectedIf(property: CSProperty<Boolean>): CSRegistration

inline fun <T> View.selectedIf(property: CSProperty<T>, crossinline condition: (T) -> Boolean): CSRegistration

inline fun <T> View.selectedIf( property1: CSProperty<T>, property2: CSProperty<*>, crossinline condition: (T) -> Boolean): CSRegistration

fun <T, V> View.selectedIf( property1: CSProperty<T>, property2: CSProperty<V>, condition: (T, V) -> Boolean): CSRegistration

fun <T, V, X> View.selectedIf( property1: CSProperty<T>, property2: CSProperty<V>, property3: CSProperty<X>, condition: (T, V, X) -> Boolean): CSRegistration

fun <T, V, X, Y> View.selectedIf( property1: CSProperty<T>, property2: CSProperty<V>, property3: CSProperty<X>, property4: CSProperty<Y>, condition: (T, V, X, Y) -> Boolean): CSRegistration

selectIf

fun View.selectIf(property: CSProperty<Boolean>): CSRegistration

fun <T> View.selectIf(property: CSProperty<T>, value: T): CSRegistration

show

fun <T : View> T.show(animated: Boolean = false): T

shownIf

fun <T : View> T.shownIf(condition: Boolean, animated: Boolean = false): T

fun View.shownIf(property: CSProperty<Boolean>, animated: Boolean = false): CSRegistration

fun <T> View.shownIf( property: CSProperty<T>, animated: Boolean = false, condition: (T) -> Boolean): CSRegistration

fun <T> View.shownIf( property1: CSProperty<T>, property2: CSProperty<*>, animated: Boolean = false, condition: (T) -> Boolean): CSRegistration

fun <T, V> View.shownIf( property1: CSProperty<T>, property2: CSProperty<V>, animated: Boolean = false, condition: (T, V) -> Boolean): CSRegistration

fun <T, V, X> View.shownIf( property1: CSProperty<T>, property2: CSProperty<V>, property3: CSProperty<X>, animated: Boolean = false, condition: (T, V, X) -> Boolean): CSRegistration

shownIfNot

fun View.shownIfNot(property: CSProperty<Boolean>, animated: Boolean = false): CSRegistration

size

fun <T : View> T.size(width: Int, height: Int): T

sortChildren

inline fun <R : Comparable<R>> ViewGroup.sortChildren(crossinline selector: (View) -> R?): ViewGroup

inline fun <R : Comparable<R>> ViewGroup.sortChildren(crossinline selector: (Int, View) -> R?): ViewGroup

spinner

fun View.spinner(@IdRes id: Int): Spinner

startMargin

fun <T : View> T.startMargin(value: Int): T

switch

fun View.switch(@IdRes id: Int): Switch

textView

fun View.textView(@IdRes id: Int): TextView

timePicker

fun View.timePicker(@IdRes id: Int): TimePicker

toggleActiveAsTrue

fun View.toggleActiveAsTrue(property: CSProperty<Boolean>): CSRegistration

toggleAsFalse

fun View.toggleAsFalse(property: CSProperty<Boolean>): CSRegistration

toggleSelectedAsTrue

fun View.toggleSelectedAsTrue(property: CSProperty<Boolean>): CSRegistration

toolbar

fun View.toolbar(@IdRes id: Int): Toolbar

topMargin

fun <T : View> T.topMargin(value: Int): T

updateVisibility

fun <T : View> T.updateVisibility()

verticalMargin

fun <T : View> T.verticalMargin(value: Int): T

view

fun View.view(@IdRes id: Int): View

viewGroup

fun View.viewGroup(@IdRes id: Int): ViewGroup

visible

fun <T : View> T.visible(animated: Boolean = false): T

visibleIf

fun <T : View> T.visibleIf(condition: Boolean, animated: Boolean = false): T

fun View.visibleIf(property: CSProperty<Boolean>, animated: Boolean = false): CSRegistration

fun <T> View.visibleIf( property: CSProperty<T>, animated: Boolean = false, condition: (T) -> Boolean): CSRegistration

fun <T> View.visibleIf( property1: CSProperty<T>, property2: CSProperty<*>, animated: Boolean = false, condition: (T) -> Boolean): CSRegistration

fun <T, V> View.visibleIf( property1: CSProperty<T>, property2: CSProperty<V>, animated: Boolean = false, condition: (T, V) -> Boolean): CSRegistration

visibleIfNot