{{ or {{/
48 | * @param tagClass The class for an implementation of {@link Tag}
49 | */
50 | public static void registerTag(String name, Class tagClass) {
51 | sTransformer.getTagFactory().registerTag(name, tagClass);
52 | }
53 |
54 | /**
55 | * Analog of {@link Context#getString(int)} for SRML.
56 | * @param context Context to retrieve the string resource from.
57 | * @param resId String resource.
58 | * @return The templatized string.
59 | */
60 | public static CharSequence getString(Context context, @StringRes int resId) {
61 | return getString(context, sTransformer, resId);
62 | }
63 |
64 | /**
65 | * Analog of {@link Context#getString(int, Object[])} for SRML.
66 | * @param context Context to retrieve the string resource from.
67 | * @param resId String resource.
68 | * @param formatArgs Format arguments for the string, passed along to {@link Context#getString(int, Object[]}
69 | * @return The templatized string.
70 | */
71 | public static CharSequence getString(Context context, @StringRes int resId, Object... formatArgs) {
72 | return getString(context, sTransformer, resId, formatArgs);
73 | }
74 |
75 | public static CharSequence[] getStringArray(Context context, @ArrayRes int resId) {
76 | return getStringArray(context, sTransformer, resId);
77 | }
78 |
79 | public static CharSequence getQuantityString(Context context, @PluralsRes int resId, int quantity) {
80 | return getQuantityString(context, sTransformer, resId, quantity);
81 | }
82 |
83 | public static CharSequence getQuantityString(Context context, @PluralsRes int resId, int quantity, Object... formatArgs) {
84 | return getQuantityString(context, sTransformer, resId, quantity, formatArgs);
85 | }
86 |
87 | public static CharSequence getString(Context context, Transformer transformer, @StringRes int resId) {
88 | return transformer.transform(context, context.getString(resId));
89 | }
90 |
91 | public static CharSequence getString(Context context, Transformer transformer, @StringRes int resId, Object... formatArgs) {
92 | return transformer.transform(context, context.getString(resId, transformer.getSanitizer().sanitizeArgs(formatArgs)));
93 | }
94 |
95 | public static CharSequence[] getStringArray(Context context, Transformer transformer, @ArrayRes int resId) {
96 | String[] strings = context.getResources().getStringArray(resId);
97 | CharSequence[] result = new CharSequence[strings.length];
98 | for (int i = 0, len = result.length; i < len; i++) {
99 | result[i] = transformer.transform(context, strings[i]);
100 | }
101 | return result;
102 | }
103 |
104 | public static CharSequence getQuantityString(Context context, Transformer transformer, @PluralsRes int resId, int quantity) {
105 | return transformer.transform(context, context.getResources().getQuantityString(resId, quantity));
106 | }
107 |
108 | public static CharSequence getQuantityString(Context context, Transformer transformer, @PluralsRes int resId, int quantity, Object... formatArgs) {
109 | return transformer.transform(context, context.getResources().getQuantityString(resId, quantity, transformer.getSanitizer().sanitizeArgs(formatArgs)));
110 | }
111 |
112 | /**
113 | * Mark up a string with SRML.
114 | * @param context Current context
115 | * @param str String to mark up.
116 | * @return Marked-up CharSequence.
117 | */
118 | public static CharSequence markup(Context context, String str) {
119 | return sTransformer.transform(context, str);
120 | }
121 | }
122 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/SRMLImageLoader.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml;
2 |
3 | import android.content.Context;
4 | import android.graphics.Bitmap;
5 |
6 | /**
7 | * Defines a class capable of loading a {@link Bitmap} from a url. Can be registered with SRML
8 | * via {@link SRML#setImageLoader(SRMLImageLoader)}.
9 | *
10 | * @author jason
11 | */
12 | public interface SRMLImageLoader {
13 | /**
14 | * Load the image at the given url and return it as a Bitmap.
15 | * @param context The current context.
16 | * @param url The image's url.
17 | * @return A bitmap of the image.
18 | */
19 | Bitmap loadImage(Context context, String url);
20 |
21 | /**
22 | * Load the image at the given url and return it as a Bitmap in the provided size..
23 | * @param context The current context.
24 | * @param url The image's url.
25 | * @param width Requested width of the image.
26 | * @param height Requested height of the image.
27 | * @return A bitmap.
28 | */
29 | Bitmap loadImage(Context context, String url, int width, int height);
30 | }
31 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/SRMLTextView.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml;
2 |
3 | import android.content.Context;
4 | import android.os.Build;
5 | import android.support.annotation.RequiresApi;
6 | import android.util.AttributeSet;
7 | import android.widget.TextView;
8 |
9 | /**
10 | * A simple extension to {@link TextView} which will automatically call out to SRML.getString when
11 | * {@link #setText(CharSequence)} is called
12 | *
13 | * @author jason
14 | */
15 |
16 | public class SRMLTextView extends TextView {
17 | public SRMLTextView(Context context) {
18 | super(context);
19 | }
20 |
21 | public SRMLTextView(Context context, AttributeSet attrs) {
22 | super(context, attrs);
23 | }
24 |
25 | public SRMLTextView(Context context, AttributeSet attrs, int defStyleAttr) {
26 | super(context, attrs, defStyleAttr);
27 | }
28 |
29 | @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
30 | public SRMLTextView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
31 | super(context, attrs, defStyleAttr, defStyleRes);
32 | }
33 |
34 | @Override
35 | public void setText(CharSequence text, BufferType type) {
36 | super.setText(SRML.markup(getContext(), text.toString()), BufferType.SPANNABLE);
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/Sanitizer.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml;
2 |
3 | import android.content.Context;
4 |
5 | /**
6 | * Defines a sanitizer for SRML. Responsible for sanitizing and de-sanitizing formatArgs passed to
7 | * {@link SRML#getString(Context, int, Object[])} and friends.
8 | *
9 | * @author jason
10 | */
11 | public interface Sanitizer {
12 | /**
13 | * Sanitize the string arguments in formatArgs by replacing instances of our tag-start borders
14 | * with equal-length replacements, so they don't get picked up by the transformer.
15 | *
16 | * Args which are an instance of {@link co.jasonwyatt.srml.utils.SafeString} should not be
17 | * sanitized.
18 | */
19 | Object[] sanitizeArgs(Object[] formatArgs);
20 |
21 | /**
22 | * Desanitize a chunk of text.
23 | */
24 | String desantitize(String s);
25 | }
26 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/Transformer.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml;
2 |
3 | import android.content.Context;
4 |
5 | import co.jasonwyatt.srml.tags.TagFactory;
6 |
7 | /**
8 | * Defines an object which is capable of transforming a given SRML-marked-up String into a
9 | * styled/spanned CharSequence according to the tags used in the string.
10 | * @author jason
11 | */
12 | public interface Transformer {
13 | CharSequence transform(Context context, String srmlString);
14 |
15 | Sanitizer getSanitizer();
16 |
17 | /**
18 | * Get the {@link TagFactory} for the transformer.
19 | */
20 | TagFactory getTagFactory();
21 | }
22 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/tags/BadParameterException.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml.tags;
2 |
3 | /**
4 | * @author jason
5 | *
6 | * This exception can be thrown by a {@link ParameterizedTag} when a parameter is invalid for some reason.
7 | */
8 | public class BadParameterException extends RuntimeException {
9 | public BadParameterException(String message) {
10 | super(message);
11 | }
12 |
13 | public BadParameterException(String message, Throwable cause) {
14 | super(message, cause);
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/tags/BadTagException.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml.tags;
2 |
3 | /**
4 | * @author jason
5 | *
6 | * Thrown when we could not find a tag class for the given tag text.
7 | */
8 | public class BadTagException extends RuntimeException {
9 | public BadTagException(String message) {
10 | super(message);
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/tags/Bold.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml.tags;
2 |
3 | import android.content.Context;
4 | import android.graphics.Typeface;
5 | import android.text.Spannable;
6 | import android.text.Spanned;
7 | import android.text.style.StyleSpan;
8 |
9 | /**
10 | * @author jason
11 | *
12 | * Tag for bolding text.
13 | */
14 | class Bold extends Tag {
15 | static final String NAME = "b";
16 |
17 | Bold(String tagStr, int taggedTextStart) {
18 | super(tagStr, taggedTextStart);
19 | }
20 |
21 | @Override
22 | public boolean matchesClosingTag(String tagName) {
23 | return NAME.equalsIgnoreCase(tagName);
24 | }
25 |
26 | @Override
27 | public void operate(Context context, Spannable builder, int taggedTextEnd) {
28 | builder.setSpan(new StyleSpan(Typeface.BOLD), getTaggedTextStart(), taggedTextEnd, Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/tags/Code.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml.tags;
2 |
3 | import android.content.Context;
4 | import android.text.Spannable;
5 | import android.text.Spanned;
6 | import android.text.style.TypefaceSpan;
7 |
8 | /**
9 | * @author jason
10 | *
11 | * Shows monospace text like source code.
12 | */
13 | class Code extends Tag {
14 | static final String NAME = "code";
15 | private static final String MONOSPACE = "monospace";
16 |
17 | public Code(String tagStr, int taggedTextStart) {
18 | super(tagStr, taggedTextStart);
19 | }
20 |
21 | @Override
22 | public boolean matchesClosingTag(String tagName) {
23 | return NAME.equalsIgnoreCase(tagName);
24 | }
25 |
26 | @Override
27 | public void operate(Context context, Spannable builder, int taggedTextEnd) {
28 | builder.setSpan(new TypefaceSpan(MONOSPACE), getTaggedTextStart(), taggedTextEnd, Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/tags/Color.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml.tags;
2 |
3 | import android.content.Context;
4 | import android.text.Spannable;
5 | import android.text.Spanned;
6 | import android.text.style.BackgroundColorSpan;
7 | import android.text.style.ForegroundColorSpan;
8 |
9 | import co.jasonwyatt.srml.utils.Utils;
10 |
11 | /**
12 | * @author jason
13 | *
14 | * Allows you to color a chunk of text.
15 | *
16 | * Usage: {{color fg=#FF00FF}}my text{{/color}} -> Magenta "my text"
17 | */
18 |
19 | class Color extends ParameterizedTag {
20 | static final String NAME = "color";
21 | private static final String PARAM_COLOR_FG = "fg";
22 | private static final String PARAM_COLOR_BG = "bg";
23 |
24 | public Color(String tagStr, int taggedTextStart) {
25 | super(tagStr, taggedTextStart);
26 | }
27 |
28 | @Override
29 | public boolean matchesClosingTag(String tagName) {
30 | return NAME.equalsIgnoreCase(tagName);
31 | }
32 |
33 | @Override
34 | public void operate(Context context, Spannable builder, int taggedTextEnd) {
35 | String colorValue = getParam(PARAM_COLOR_FG);
36 | if (colorValue != null) {
37 | builder.setSpan(new ForegroundColorSpan(Utils.getColorInt(context, colorValue)), getTaggedTextStart(), taggedTextEnd, Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
38 | }
39 |
40 | colorValue = getParam(PARAM_COLOR_BG);
41 | if (colorValue != null) {
42 | builder.setSpan(new BackgroundColorSpan(Utils.getColorInt(context, colorValue)), getTaggedTextStart(), taggedTextEnd, Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
43 | }
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/tags/CouldNotCreateTagException.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml.tags;
2 |
3 | /**
4 | * @author jason
5 | * Thrown by the {@link TagFactory} when a tag could not be instantiated.
6 | */
7 | public class CouldNotCreateTagException extends RuntimeException {
8 | CouldNotCreateTagException(Exception e, String tagName) {
9 | super("Error instantiating Tag with name: "+tagName, e);
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/tags/CouldNotRegisterTagException.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml.tags;
2 |
3 | /**
4 | * @author jason
5 | *
6 | * Thrown when we could not register a user-supplied Tag class.
7 | */
8 | public class CouldNotRegisterTagException extends RuntimeException {
9 | CouldNotRegisterTagException(Throwable e, Class tagClass) {
10 | super("Could not register "+tagClass.getName(), e);
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/tags/DrawableTag.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml.tags;
2 |
3 | import android.content.Context;
4 | import android.graphics.drawable.BitmapDrawable;
5 | import android.graphics.drawable.Drawable;
6 | import android.os.Build;
7 | import android.text.Spannable;
8 | import android.text.Spanned;
9 | import android.text.style.DynamicDrawableSpan;
10 | import android.text.style.ImageSpan;
11 |
12 | import co.jasonwyatt.srml.utils.Utils;
13 |
14 | /**
15 | * The DrawableTag allows you to embed images in string resources.
16 | *
17 | * {{drawable res=R.drawable.app_icon /}}
18 | *
19 | * This is a self-closable tag that can be empty, so note that you need the " /" before the closing
20 | * "}}"
21 | *
22 | * @author jason
23 | */
24 | class DrawableTag extends ParameterizedTag {
25 | static final String NAME = "drawable";
26 | private static final String PARAM_NAME_RES = "res";
27 | private static final String PARAM_NAME_URL = "url";
28 | private static final String PARAM_NAME_WIDTH = "width";
29 | private static final String PARAM_NAME_HEIGHT = "height";
30 | private static final String PARAM_NAME_ALIGNMENT = "align";
31 | private static final String PARAM_VALUE_ALIGN_BASELINE = "baseline";
32 | private static final String PARAM_VALUE_ALIGN_BOTTOM = "bottom";
33 |
34 | /**
35 | * {@inheritDoc}
36 | *
37 | * @param tagStr
38 | * @param taggedTextStart
39 | */
40 | public DrawableTag(String tagStr, int taggedTextStart) {
41 | super(tagStr, taggedTextStart);
42 | }
43 |
44 | @Override
45 | public boolean canBeEmpty() {
46 | return true;
47 | }
48 |
49 | @Override
50 | public int getRequiredSpacesWhenEmpty() {
51 | return 1;
52 | }
53 |
54 | @Override
55 | public boolean matchesClosingTag(String tagName) {
56 | return NAME.equalsIgnoreCase(tagName);
57 | }
58 |
59 | @Override
60 | public void operate(Context context, Spannable spannable, int taggedTextEnd) {
61 | spannable.setSpan(new ImageSpan(loadDrawable(context), getVerticalAlignment()), getTaggedTextStart(), taggedTextEnd, Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
62 | }
63 |
64 | private int getVerticalAlignment() {
65 | String alignmentRaw = getParam(PARAM_NAME_ALIGNMENT);
66 | if (alignmentRaw == null) {
67 | return DynamicDrawableSpan.ALIGN_BASELINE;
68 | }
69 | switch (alignmentRaw) {
70 | case PARAM_VALUE_ALIGN_BASELINE:
71 | return DynamicDrawableSpan.ALIGN_BASELINE;
72 | case PARAM_VALUE_ALIGN_BOTTOM:
73 | return DynamicDrawableSpan.ALIGN_BOTTOM;
74 | default:
75 | throw new BadParameterException("Invalid alignment param for tag: "+getTagStr());
76 | }
77 | }
78 |
79 | private Drawable loadDrawable(Context context) {
80 | Drawable result = null;
81 | String resId = getParam(PARAM_NAME_RES);
82 | String url = getParam(PARAM_NAME_URL);
83 | int widthPixels = Utils.getPixelSize(context, getParam(PARAM_NAME_WIDTH));
84 | int heightPixels = Utils.getPixelSize(context, getParam(PARAM_NAME_HEIGHT));
85 |
86 | if (resId != null) {
87 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
88 | result = context.getResources().getDrawable(Utils.getIdentifier(context, resId), context.getTheme());
89 | } else {
90 | //noinspection deprecation
91 | result = context.getResources().getDrawable(Utils.getIdentifier(context, resId));
92 | }
93 | } else if (url != null) {
94 | result = new BitmapDrawable(context.getResources(), Utils.loadImage(context, url, widthPixels, heightPixels));
95 | }
96 |
97 | if (result == null) {
98 | throw new BadParameterException("Could not load a drawable for tag: "+getTagStr());
99 | }
100 | if (widthPixels > 0 && heightPixels > 0) {
101 | result.setBounds(0, 0, widthPixels, heightPixels);
102 | } else if (widthPixels > 0) {
103 | result.setBounds(0, 0, widthPixels, result.getIntrinsicHeight());
104 | } else if (heightPixels > 0) {
105 | result.setBounds(0, 0, result.getIntrinsicWidth(), heightPixels);
106 | } else {
107 | result.setBounds(0, 0, result.getIntrinsicWidth(), result.getIntrinsicHeight());
108 | }
109 | return result;
110 | }
111 | }
112 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/tags/FontTag.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml.tags;
2 |
3 | import android.content.Context;
4 | import android.support.annotation.Nullable;
5 | import android.text.Spannable;
6 | import android.text.Spanned;
7 | import android.text.TextUtils;
8 | import android.text.style.TextAppearanceSpan;
9 |
10 | import java.util.regex.Pattern;
11 |
12 | import co.jasonwyatt.srml.utils.FontSpan;
13 | import co.jasonwyatt.srml.utils.Utils;
14 |
15 | /**
16 | * A powerful tag to configure several attributes of the font.
17 | * @author jason
18 | */
19 | class FontTag extends ParameterizedTag {
20 | static final String NAME = "font";
21 | private static final String PARAM_COLOR_FG = "fg";
22 | private static final String PARAM_COLOR_BG = "bg";
23 | private static final String PARAM_TYPEFACE = "typeface";
24 | private static final String PARAM_STYLE = "style";
25 | private static final String PARAM_LETTER_SPACING = "letter_spacing";
26 | private static final String PARAM_LINE_HEIGHT = "line_height";
27 | private static final String PARAM_TEXT_APPEARANCE = "text_appearance";
28 | private static final String PARAM_TEXT_SIZE = "size";
29 | private static final Pattern STYLE_DIVIDER = Pattern.compile("\\|");
30 | private static final String STYLE_UNDERLINE = "underline";
31 | private static final String STYLE_BOLD = "bold";
32 | private static final String STYLE_ITALIC = "italic";
33 | private static final String STYLE_STRIKETHROUGH = "strike";
34 | private static final String STYLE_SUPERSCRIPT = "super";
35 | private static final String STYLE_SUBSCRIPT = "sub";
36 | private int mStart;
37 | private int mEnd;
38 |
39 | FontTag(String tagStr, int taggedTextStart) {
40 | super(tagStr, taggedTextStart);
41 | }
42 |
43 | @Override
44 | public boolean matchesClosingTag(String tagName) {
45 | return NAME.equalsIgnoreCase(tagName);
46 | }
47 |
48 | @Override
49 | public void operate(Context context, Spannable spannable, int taggedTextEnd) {
50 | mStart = getTaggedTextStart();
51 | mEnd = taggedTextEnd;
52 |
53 | String textAppearanceValue = getParam(PARAM_TEXT_APPEARANCE);
54 | if (!TextUtils.isEmpty(textAppearanceValue)) {
55 | applySpan(spannable, new TextAppearanceSpan(context, Utils.getIdentifier(context, textAppearanceValue)));
56 | }
57 |
58 | FontSpan.Builder span = new FontSpan.Builder();
59 |
60 | String letterSpacingValue = getParam(PARAM_LETTER_SPACING);
61 | float letterSpacing;
62 | if (!TextUtils.isEmpty(letterSpacingValue)) {
63 | try {
64 | letterSpacing = Float.parseFloat(letterSpacingValue);
65 | } catch (NumberFormatException nfe) {
66 | throw new BadParameterException("Invalid letter_spacing value:"+letterSpacingValue, nfe);
67 | }
68 | if (letterSpacing < 0) {
69 | throw new BadParameterException("letter_spacing cannot be less than 0: "+getTagStr());
70 | }
71 | span.spacing(letterSpacing);
72 | }
73 |
74 | String lineHeightValue = getParam(PARAM_LINE_HEIGHT);
75 | if (!TextUtils.isEmpty(lineHeightValue)) {
76 | span.lineHeight(Utils.getPixelSize(context, lineHeightValue));
77 | }
78 |
79 | span.flags(getStyles(getParam(PARAM_STYLE)));
80 |
81 |
82 | String fgValue = getParam(PARAM_COLOR_FG);
83 | if (!TextUtils.isEmpty(fgValue)) {
84 | span.foregroundColor(Utils.getColorInt(context, fgValue));
85 | }
86 |
87 | String bgValue = getParam(PARAM_COLOR_BG);
88 | if (!TextUtils.isEmpty(bgValue)) {
89 | span.backgroundColor(Utils.getColorInt(context, bgValue));
90 | }
91 |
92 | String typefaceValue = getParam(PARAM_TYPEFACE);
93 | if (!TextUtils.isEmpty(typefaceValue)) {
94 | span.typeface(typefaceValue);
95 | }
96 |
97 | String sizeValue = getParam(PARAM_TEXT_SIZE);
98 | if (!TextUtils.isEmpty(sizeValue)) {
99 | span.textSize(Utils.getPixelSize(context, sizeValue));
100 | }
101 |
102 | applySpan(spannable, span.build());
103 |
104 | }
105 |
106 | private int getStyles(@Nullable String styleString) {
107 | int styleSpanValue = 0;
108 | if (TextUtils.isEmpty(styleString)) {
109 | return styleSpanValue;
110 | }
111 |
112 | String[] styles = STYLE_DIVIDER.split(styleString);
113 | boolean seenSuperSub = false;
114 | for (String style : styles) {
115 | switch (style) {
116 | case STYLE_BOLD:
117 | styleSpanValue |= FontSpan.FLAG_BOLD;
118 | break;
119 | case STYLE_ITALIC:
120 | styleSpanValue |= FontSpan.FLAG_ITALIC;
121 | break;
122 | case STYLE_UNDERLINE:
123 | styleSpanValue |= FontSpan.FLAG_UNDERLINE;
124 | break;
125 | case STYLE_STRIKETHROUGH:
126 | styleSpanValue |= FontSpan.FLAG_STRIKETHROUGH;
127 | break;
128 | case STYLE_SUPERSCRIPT:
129 | if (seenSuperSub) {
130 | throw new BadParameterException("\"super\" style requested, but \"sub\" or \"super\" was already in the {{font}} style: "+styleString);
131 | }
132 | styleSpanValue |= FontSpan.FLAG_SUPERSCRIPT;
133 | seenSuperSub = true;
134 | break;
135 | case STYLE_SUBSCRIPT:
136 | if (seenSuperSub) {
137 | throw new BadParameterException("\"sub\" style requested, but \"sub\" or \"super\" was already in the {{font}} style: "+styleString);
138 | }
139 | styleSpanValue |= FontSpan.FLAG_SUBSCRIPT;
140 | seenSuperSub = true;
141 | break;
142 | default:
143 | throw new BadParameterException("Invalid value for {{font}} style: "+style+" in "+styleString);
144 | }
145 | }
146 |
147 | return styleSpanValue;
148 | }
149 |
150 | private void applySpan(Spannable s, Object o) {
151 | s.setSpan(o, mStart, mEnd, Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
152 | }
153 |
154 | }
155 |
--------------------------------------------------------------------------------
/library/src/main/java/co/jasonwyatt/srml/tags/IntentTag.java:
--------------------------------------------------------------------------------
1 | package co.jasonwyatt.srml.tags;
2 |
3 | import android.content.Context;
4 | import android.content.Intent;
5 | import android.os.Bundle;
6 | import android.support.annotation.NonNull;
7 | import android.support.annotation.Nullable;
8 | import android.text.Spannable;
9 | import android.text.Spanned;
10 | import android.view.View;
11 |
12 | import java.util.List;
13 | import java.util.regex.Matcher;
14 | import java.util.regex.Pattern;
15 |
16 | import co.jasonwyatt.srml.utils.Utils;
17 |
18 | /**
19 | * @author jason
20 | *
21 | * This tag can be used to launch an activity or a service.
22 | *
23 | * {{intent class=com.yourcompany.ActivityName action=android.intent.action.VIEW for_service=false x_extraKey=extraValue }}
24 | *
25 | * class
26 | * REQUIRED.
27 | * The fully-qualified name of the activity or service you intend to start.
28 | * for_service
29 | * OPTIONAL.
30 | * Denotes whether or not to call context.startService(intent) instead of
31 | * context.startActivity(intent)
32 | * action
33 | * OPTIONAL.
34 | * what you'd specify in intent.setAction(..)
35 | * x_[extraKey]
36 | * OPTIONAL.
37 | * Intent extras with [extraKey] names. They allow you to supply additional information about
38 | * how to parse and send the parameter values to the target.
39 | */
40 | public class IntentTag extends ParameterizedTag {
41 | static final String NAME = "intent";
42 | private static final Pattern EXTRAS_KEY_PATTERN = Pattern.compile("x_[^=]+");
43 | private static final String TYPE_INT = "int";
44 | private static final String TYPE_LONG = "long";
45 | private static final String TYPE_CHAR = "char";
46 | private static final String TYPE_FLOAT = "float";
47 | private static final String TYPE_DOUBLE = "double";
48 | private static final String TYPE_BYTE = "byte";
49 | private static final String TYPE_SHORT = "short";
50 | private static final String[] TYPES = {
51 | TYPE_INT, TYPE_LONG, TYPE_CHAR, TYPE_FLOAT, TYPE_DOUBLE, TYPE_SHORT, TYPE_BYTE,
52 | };
53 | private static final Pattern EXTRAS_VALUE_CAST_PATTERN = Pattern.compile("((" + Utils.join("|", TYPES) + ")\\((-?[0-9]+(\\.[0-9]+)?|[^ ])\\))|(true|false)");
54 | private static final String PARAM_CLASS = "class";
55 | private static final String PARAM_FOR_SERVICE = "for_service";
56 | private static final String PARAM_ACTION = "action";
57 | String mTargetClass;
58 | String mAction;
59 | Bundle mExtras;
60 | boolean mIsForService;
61 |
62 | IntentTag(String tagStr, int taggedTextStart) {
63 | super(tagStr, taggedTextStart);
64 | parseParams();
65 | }
66 |
67 | private void parseParams() {
68 | mTargetClass = getParam(PARAM_CLASS);
69 | if (mTargetClass == null || mTargetClass.length() == 0) {
70 | throw new BadParameterException("No class parameter specified at " + getTaggedTextStart());
71 | }
72 |
73 | String forService = getParam(PARAM_FOR_SERVICE);
74 | mIsForService = forService != null && "true".equalsIgnoreCase(forService);
75 |
76 | mAction = getParam(PARAM_ACTION);
77 | Listname=value pairs after the tag name in the opening tag.param_name=param_value if you do not need spaces, orparam_name=`param value` if your param does need spacestrue, the {@link Transformer} will call
49 | * {@link #getRequiredSpacesWhenEmpty()} before it calls {@link #operate(Context, Spannable, int)}
50 | *
51 | * @return Whether the tag can be empty.
52 | */
53 | public boolean canBeEmpty() {
54 | return false;
55 | }
56 |
57 | /**
58 | * When true is returned from {@link #canBeEmpty()}, this method will be called to
59 | * allow you to specify a number of non-breaking spaces required by the Tag. When
60 | * {@link #operate(Context, Spannable, int)} is called, it will be passed the value from
61 | * {@link #getTaggedTextStart()} plus the return value from this method.
62 | *
63 | * @return The number of required non-breaking spaces for the tag.
64 | */
65 | public int getRequiredSpacesWhenEmpty() {
66 | return 0;
67 | }
68 |
69 | /**
70 | * Return whether or not the closing tag seen matches this tag.NOTE: This is only supported on Lollipop or higher.
141 | * @param spacing Spacing. 142 | * @return The builder. 143 | */ 144 | public Builder spacing(float spacing) { 145 | mSpacing = spacing; 146 | return this; 147 | } 148 | 149 | /** 150 | * Set the line height for the span (in pixels). 151 | * @param lineHeightPx New line height. 152 | * @return The builder. 153 | */ 154 | public Builder lineHeight(int lineHeightPx) { 155 | mLineHeight = lineHeightPx; 156 | return this; 157 | } 158 | 159 | /** 160 | * Set the flags for the FontSpan. Can be a bitwise or of any of the following values: 161 | ** - Only one of {@link #FLAG_SUBSCRIPT} or {@link #FLAG_SUPERSCRIPT} may be used.
170 | * @param flags Flags to set. 171 | * @return The builder. 172 | */ 173 | public Builder flags(int flags) { 174 | mFlags = flags; 175 | return this; 176 | } 177 | 178 | /** 179 | * Sets the text foreground color. 180 | * @param foregroundColor The foreground color for the text. 181 | * @return The builder. 182 | */ 183 | public Builder foregroundColor(@ColorInt int foregroundColor) { 184 | mForegroundColor = foregroundColor; 185 | mHasForegroundColor = true; 186 | return this; 187 | } 188 | 189 | /** 190 | * Sets the text background color. 191 | * @param backgroundColor The background color for the text. 192 | * @return The builder. 193 | */ 194 | public Builder backgroundColor(@ColorInt int backgroundColor) { 195 | mBackgroundColor = backgroundColor; 196 | mHasBackgroundColor = true; 197 | return this; 198 | } 199 | 200 | /** 201 | * Sets the text size. 202 | * @param sizePixels The text size (in pixels) 203 | * @return The builder. 204 | */ 205 | public Builder textSize(int sizePixels) { 206 | mTextSize = sizePixels; 207 | return this; 208 | } 209 | 210 | /** 211 | * Sets the typeface string. 212 | * @param typeface New typeface identifier string. 213 | * @return The builder. 214 | */ 215 | public Builder typeface(String typeface) { 216 | mTypeface = typeface; 217 | return this; 218 | } 219 | 220 | /** 221 | * Construct a FontSpan from the builder. 222 | * @return A new {@link FontSpan} 223 | */ 224 | public FontSpan build() { 225 | return new FontSpan(this); 226 | } 227 | } 228 | } 229 | -------------------------------------------------------------------------------- /library/src/main/java/co/jasonwyatt/srml/utils/SafeString.java: -------------------------------------------------------------------------------- 1 | package co.jasonwyatt.srml.utils; 2 | 3 | import android.support.annotation.NonNull; 4 | 5 | import java.io.Serializable; 6 | 7 | /** 8 | * Simple wrapper of {@link String} which the {@link co.jasonwyatt.srml.Sanitizer} should look for, 9 | * and skip the escape process. 10 | * 11 | * @author jason 12 | */ 13 | 14 | public class SafeString implements CharSequence, Serializable { 15 | private final String mString; 16 | 17 | public SafeString(@NonNull String s) { 18 | mString = s; 19 | } 20 | 21 | public boolean isEmpty() { 22 | return mString.isEmpty(); 23 | } 24 | 25 | /** 26 | * Returns the length of this SafeString. The length is the number 27 | * of 16-bitchars in the sequence.
28 | *
29 | * @return the number of chars in this sequence
30 | */
31 | @Override
32 | public int length() {
33 | return mString.length();
34 | }
35 |
36 | /**
37 | * Returns the char value at the specified index. An index ranges from zero
38 | * to length() - 1. The first char value of the sequence is at
39 | * index zero, the next at index one, and so on, as for array
40 | * indexing.
41 | *
42 | * If the char value specified by the index is a
43 | * surrogate, the surrogate
44 | * value is returned.
45 | *
46 | * @param index the index of the char value to be returned
47 | *
48 | * @return the specified char value
49 | *
50 | * @throws IndexOutOfBoundsException
51 | * if the index argument is negative or not less than
52 | * length()
53 | */
54 | @Override
55 | public char charAt(int index) {
56 | return mString.charAt(index);
57 | }
58 |
59 | /**
60 | * Returns a new CharSequence that is a subsequence of this sequence.
61 | * The subsequence starts with the char value at the specified index and
62 | * ends with the char value at index end - 1. The length
63 | * (in chars) of the
64 | * returned sequence is end - start, so if start == end
65 | * then an empty sequence is returned.