cc @elihart

This would make it easier to reuse styles, especially in a context where styles have to declare the same attributes which makes combining them useless.

val dangerTextStyle = viewStyle {
    textColor(Color.RED)
}

val bigDangerTextStyle = viewStyle {
    // This uses the text color from the given style
    textColor(dangerTextStyle)
    textSizeDp(36)
    ...
}

Otherwise modules that don't contain @Styleable classes are unable to generate a Paris class, which can be useful to aggregate multiple modules.

It will be really cool to use this as app:styles="@Style/Style1, @Style/Style2".
Do you think it is possible (even if need to create wrapper for each view)?

Rather than going through the Paris class (Paris.style(view)...) extensions could be generated for each view type:

fun View.style(style: Style) {
    ViewStyleApplier(this).apply(style)
}

fun View.style(init: ViewStyleApplier.StyleBuilder.() -> Unit) {
    ViewStyleApplier.StyleBuilder().let {
        it.init()
        it.applyTo(this)
    }
}

// Linked style
fun View.styleGreen() {
    ViewStyleApplier(this).apply(R.style.Green)
}

In action:

Paris.style(view).apply(R.style.Green)
// Could be replaced by:
view.style(R.style.Green)

Paris.styleBuilder(view)
        .add(R.style.MyGreenTextView)
        .textSizeRes(R.dimen.my_text_size_small)
        .apply();
// Could be replaced by:
view.style {
    add(R.style.MyGreenTextView)
    textSizeRes(R.dimen.my_text_size_small)
}

Paris.style(view).applyGreen()
// Could be replaced by:
view.styleGreen()

cc @elihart

Certain Robolectric unit tests require custom resources (styles notably) but the only way to have access to those is to put them among regular resources which means they ship with the library. The number of such resources is currently tiny but it'd be nice to find a way to exclude them (instrumentation tests for example can have their own test-specific resources).

(I could also move those tests to paris-test.)

For example:

Java

class MyView ... {

    @Style
    static final Style MY_STYLE = new MyViewStyleApplier.StyleBuilder()
            .background(...)
            .padding(...)
            .build()

    ...
}

Kotlin

class MyView ... {

    companion object {

        @Style
        val MY_STYLE = myViewStyle {
            background(...)
            padding(...)
        }
    }

    ...
}

https://docs.gradle.org/4.7/userguide/java_plugin.html#sec:incremental_annotation_processing

Given the limitations it seems unlikely that we'd be able to use it now (can't use the Trees API), but perhaps in the future.

Paris 1.0.0
Epoxy 2.12.0
Android library module (though it shouldn't make a difference)

I'm using Paris to take advantage of @Attr annotation. Following example should produce view with red background (which is specified in the default layout). However, it looks like the styling is cleared due to some Paris magic.

Component.kt
------------
@ModelView(defaultLayout = R2.layout.default_component_layout)
@Styleable("Component")
class Component @JvmOverloads constructor(
        context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0) :
        ConstraintLayout(context, attrs, defStyleAttr) {

    init {
        inflate(R.layout.component_inner_layout)
        Paris.style(this).apply(attrs)
    }

    @Attr(R2.styleable.Component_title)
    @TextProp
    fun setTitle(text: CharSequence) {
        title.text = text // kotlinx.android.syntethic
    }

}

default_component_layout.xml
----------------------------
<my.package.Component xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="56dp"
    android:background="@color/red"/>

component_inner_layout.xml
-----------------------
<merge xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:parentTag="android.support.constraint.ConstraintLayout">

    <TextView
        android:id="@+id/title"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:text="Test" />

</merge>

attrs.xml
---------
<declare-styleable name="Component">
    <attr name="title" format="string" />
</declare-styleable>

Removing Paris from the view makes the default layout styling work correctly:

Component.kt
------------
@ModelView(defaultLayout = R2.layout.default_component_layout)
// @Styleable("Component")
class Component @JvmOverloads constructor(
        context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0) :
        ConstraintLayout(context, attrs, defStyleAttr) {

    init {
        inflate(R.layout.component_inner_layout)
        // Paris.style(this).apply(attrs)
    }

    // @Attr(R2.styleable.Component_title)
    @TextProp
    fun setTitle(text: CharSequence) {
        title.text = text // kotlinx.android.syntethic
    }

}

Having to always specify a name for styles as part of @Style is rather verbose, especially for views with lots of styles. Could formatting options be provided instead to make the explicit name optional?

• By default if the name isn't specified it could remove the @Styleable's name if it is a prefix. Eg if the styleable name is "MyView" and the style name is "MyView_Red" then it would automatically be set to "Red". This also implies that the "_" character is removed automatically.
• For more complex cases we could provide "removeStylePrefix" and "removeStyleSuffix" parameters to @Styleable. Eg the styleable name is "MyTextView" and the style names are as follow "TextTitle1", "TextTitle2", and "TextRegular". By setting removeStylePrefix = "Text" the resulting style names would be "Title1", "Title2", and "Regular".

What to add to proguard if minifyEnabled true?

Currently i'm using

com.airbnb.android:paris:1.1.0-SNAPSHOT

And i'm getting error value when styling my EditText programmatically, it give me textVisiblePassword instead of textPassword

Here is my code in my fragment

        EditText passEt = new EditText(getContext());
        passEt.setId(new ViewUtil().setViewId());
        Paris.style(passEt).apply(R.style.custom_password_et);
        RelativeLayout.LayoutParams testP = new 
        RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT, dimensionToDp(50));
        passEt.setLayoutParams(testP);

Style that i used in styles.xml

    <style name="custom.password_et" parent="@android:style/Widget.EditText">
        <item name="android:layout_marginTop">@dimen/margin_normal</item>
        <item name="android:hint">@string/hint_password</item>
        <item name="android:background">@drawable/et_rounded</item>
        <item name="android:inputType">textPassword</item>
        <item name="android:maxLines">1</item>
        <item name="android:padding">@dimen/margin_small</item>
        <item name="android:paddingStart">@dimen/padding_start</item>
        <item name="android:paddingEnd">@dimen/view_grid_item_close_size</item>
        <item name="android:singleLine">true</item>
        <item name="android:textColor">@color/colorMaterialBlack</item>
        <item name="android:textColorHint">@color/colorMaterialBlackBlur</item>
    </style>

Please fix this bug, thanks

This could be applicable to Java but especially makes sense with Kotlin where styles can be declared outside of classes:

// Can be in any file, in any module

@Style
val MY_STYLE_1 = R.style.MyStyle

@Style
val MY_STYLE_2 = myViewStyle {
    background(...)
    padding(...)
    ...
}

For example: null drawables, or cases where a "fake" null resource is used.

If a custom view is inflated from XML with a style I don't think we'd apply the ignoreLayoutWidthAndHeight value if set.

I want to implement Style from my .xml, unfortunatelly it can't implement style that has "." in their name.
Example : I can't implement "AppTheme.CustomStyle", but when i remove the ".", my style name become AppThemeCustomStyle, then it can implement it.

For example:

@ParisConfig(defaultStyleableNameFormat = "%s")

With a view such as:

@Styleable
class MyView ...

Would automatically look for R.styleable.MyView since the value isn't specified.

Current substyle builder in Kotlin:

Paris.styleBuilder(myView)
        .titleStyle {
            it.textColor(...)
            it.textSize(...)
        }

Ideally we'd be able to write:

Paris.styleBuilder(myView)
        .titleStyle {
            textColor(...)
            textSize(...)
        }

It's currently unclear to me how to achieve this while maintaining good Java interop.

cc @elihart

https://github.com/gradle/kotlin-dsl

Right now Kotlin fields are problematic because the annotation processor generates code that tries to access the backing field (which is private) rather than the getter.

This would be notably useful in the BaseView case where many of the subclasses may not need to change their style from the parent. This could eventually become the default behavior but a non-breaking change could look like:

class BaseView ... {
    @Style(transmit = true)
    val defaultStyle = baseViewStyle { ... }
}

(Not quite sure about the parameter name.)

cc @elihart @reavcn

Wondering if something like this would be useful:

val style = myViewStyle {
    backgroundRes { myView ->
        if (myView.something()) {
            R.drawable.something_background
        } else {
            R.drawable.another_background
        }
    }
}

Could this become a reactive pattern? For example a single style could differ depending on whether the view is enabled or not, all we'd need is a way to know when to refresh/re-apply the style.

Note: we wouldn't want to whole style to have access to the view instance to avoid differing attribute sets depending on conditions.

To provide a better error message (including the view at fault).

To reduce the number of " not found."

cc @elihart

I try to styling my AppBarLayout and Toolbar programmatically using Paris.
But, it's not work, may be because Paris not support it yet?
Really need help for styling that AppBarLayout and Toolbar programmatically.
And i wonder, in xml i use android:theme for styling AppBarLayout and Toolbar, is it same with styling right?

Change param of annotation Styleable from String to int (R.styleable.*), example:

@Styleable(R.styleable.MyView)
public class MyView extends LinearLayout {

For Drawable attributes we could generate a style builder method/function with a parameter of type @ColorInt int which would automatically create a ColorDrawable.

my style has "android:hint" and "android:inputType", im styling for EditText, but when i apply with Paris, it's not working, please help, thanks

One use case brought up by avipars and bernaferrari in this Reddit thread would be to easily toggle between a light and dark theme. (It would be a cool thing to showcase in the sample app.) This has also been requested internally at Airbnb by multiple teams.

The interface could look something like:

Paris.theme(activity).apply(R.style.Theme_Dark);

This would need to traverse the view hierarchy to change the style of all the views (or views grouped instead a @Styleable custom view). One issue becomes obvious: Paris would need to know which style to apply to each view type. Two solutions come to mind:

1. Views could store the last style applied to them in a tag (with programmatic styles this could be costly memory-wise as styles might include drawables and the likes -- presumably they would also be used by the view but then again, maybe this would prevent them from being garbage collected).
2. Linked styles could be leveraged to create groups of styles, ie. Paris' own version of themes. For example:

// Each component view would need to declare styles belonging to these groups
@Styleable
public class MyView ... {
    @Style("Dark") static final int DARK_STYLE = R.style.MyView_Dark;
    @Style("Light") static final int LIGHT_STYLE = R.style.MyView_Light;

    ...
}

(Instead of a string parameter it could also be a separate annotation: @Dark @Style)

Then the following methods could be generated:

Paris.theme(activity).applyDark();
Paris.theme(activity).applyLight();

Here we would traverse the view hierarchy and apply the appropriate style to @Styleable views that support it. It might be a little more cumbersome to setup but one of the benefit is each component view is still declaring explicitly the styles it supports rather than relying on arbitrary theme attributes. One caveat, especially for the dark/light case is all view components would need to support it.

Other considerations:

• How would this work in a context where views are recycled?
  Perhaps applying a theme could alter the behavior of the applyDefault() methods where the default style becomes the ones set by the theme.
• Could we make it so that styles could be customized in addition to the theme style being applied (for example in the context of an Epoxy controller)?
  This works out of the box for partial styles applied directly to models as long as we want the customization to override the theme and not the other way around.

Would it be possible to get the enum object instead of the int index?

And link to Epoxy docs: https://github.com/airbnb/epoxy/wiki/Paris-Integration-(Dynamic-Styling)